B ú‹d~;ã@stdZddlZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z ddl Z ddlZddlmZddlmZy ddlZWnek r dZYnXy ddlZWnek rÆdZYnXdd d d d d dddddddddgZe ee ej¡jƒ¡Ze dddddddddd d!d"d#d$d%d&d'gƒZe d(ddddd!d"d#d$d%g ƒZ d)Z!Gd*d„dƒZ"Gd+d„dƒZ#Gd,d„dƒZ$Gd-d„dƒZ%e d.d/d0d1d2gƒZ&ddddej' ej'dfd3d4„Z(ddddej' ej'fd5d6„Z)ddddej' ej'fd7d8„Z*ddddej' ej'fd9d:„Z+d;dd?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRgZ,GdSdT„dTƒZ-e-jdUe.dV /dWdX„e,Dƒ¡ƒdV7_dYdZ„Z0d[d„Z1d\d]„Z2d^d_„Z3d‰d`da„Z4dbdc„Z5ddde„Z6dŠdfd„Z7dgdh„Z8did „Z9d‹djd „Z:dŒdkd „Z;dldm„ZdŽdrds„Z?dtdu„Z@ddvd „ZAddwd„ZBd‘dyd„ZCd’dzd„ZDd{d|„ZEd“d~d„ZFd”dd€„ZGdd‚„ZHd•dƒd„„ZId–d…d†„ZJd‡dˆ„ZKdS)—z$ A collection of useful functions. éN)Ú namedtuple)Úpartial)Ú logsumexpé)Ú __version__Ú unitcheckÚresample_equalÚ mean_and_covÚquantileÚ jitter_runÚ resample_runÚ reweight_runÚ unravel_runÚ merge_runsÚ kld_errorÚget_enlarge_bootstrapÚ LoglOutputÚ LogLikelihoodÚ RunRecordÚ DelayTimerÚIteratorResultZworstZustarZvstarÚloglstarÚlogvolÚlogwtÚlogzÚlogzvarÚhÚncZworst_itÚboundidxÚ bounditerÚeffÚ delta_logzÚblobÚIteratorResultShortgœuˆ<ä7þc@sHeZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dS)rz² Class that encapsulates the output of the likelihood function. The reason we need this wrapper is to preserve the blob associated with the likelihood function. cCs$|r|d|_|d|_n||_dS)a- Initialize the object Parameters ---------- v: float or tuple if blob_flag is true v have to be a tuple of logl and blob if it is False v is just logl blob_flag: boolean flag to mark whether the v has a blob or not rrN)Úvalr")ÚselfÚvZ blob_flag©r'úZ/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/dynesty/utils.pyÚ__init__?s   zLoglOutput.__init__cCst|ƒt|ƒkS)zS Comparison override, we just use .val attribute in the comparison )Úfloat)r%Úv1r'r'r(Ú__lt__QszLoglOutput.__lt__cCst|ƒt|ƒkS)zS Comparison override, we just use .val attribute in the comparison )r*)r%r+r'r'r(Ú__gt__WszLoglOutput.__gt__cCst|ƒt|ƒkS)zS Comparison override, we just use .val attribute in the comparison )r*)r%r+r'r'r(Ú__le__]szLoglOutput.__le__cCst|ƒt|ƒkS)zS Comparison override, we just use .val attribute in the comparison )r*)r%r+r'r'r(Ú__ge__cszLoglOutput.__ge__cCst|ƒt|ƒkS)zS Comparison override, we just use .val attribute in the comparison )r*)r%r+r'r'r(Ú__eq__iszLoglOutput.__eq__cCs t|jƒS)zS Comparison override, we just use .val attribute in the comparison )r*r$)r%r'r'r(Ú __float__oszLoglOutput.__float__N) Ú__name__Ú __module__Ú __qualname__Ú__doc__r)r,r-r.r/r0r1r'r'r'r(r7sc@sJeZdZdZddd„Zdd„Zdd „Zd d „Zd d „Zdd„Z dd„Z dS)rz‡ Class that calls the likelihood function (using a pool if provided) Also if requested it saves the history of evaluations NFcCsL||_||_g|_g|_d|_||_||_||_d|_||_ |rH|  ¡dS)a9 Initialize the object. Parameters ---------- loglikelihood: function ndim: int Dimensionality pool: Pool (optional) Any kind of pool capable of performing map() save: bool if True the function evaluations will be saved in the hdf5 file history_filename: string The filename where the history will go blob: boolean if True we expect the logl output to be a tuple of logl value and a blob, otherwise it'll be logl value only i'FN) Ú loglikelihoodÚpoolÚ history_parsÚ history_loglÚ save_everyÚsaveÚhistory_filenameÚndimÚ failed_saver"Ú history_init)r%r6r=r7r;r<r"r'r'r(r)|szLogLikelihood.__init__cshˆjdkr*t‡fdd„tˆj|ƒDƒƒ}n‡fdd„ˆj ˆj|¡Dƒ}ˆjrdˆ dd„|Dƒ|¡|S)zÞ Evaluate the likelihood function on the list of vectors The pool is used if it was provided when the object was created Returns ------- ret: The list of LoglOutput objects Ncsg|]}t|ˆjƒ‘qSr')rr")Ú.0Ú_)r%r'r(ú ¬sz%LogLikelihood.map..csg|]}t|ˆjƒ‘qSr')rr")r@rA)r%r'r(rB°scSsg|] }|j‘qSr')r$)r@rAr'r'r(rB´s)r7ÚlistÚmapr6r;Úhistory_append)r%ÚparsÚretr')r%r(rD¡s  zLogLikelihood.mapcCs.t| |¡|jƒ}|jr*| |jg|g¡|S)z2 Evaluate the likelihood f-n once )rr6r"r;rEr$)r%ÚxrGr'r'r(Ú__call__·szLogLikelihood.__call__cCs4|j |¡|j |¡t|jƒ|jkr0| ¡dS)zd Append to the internal history the list of loglikelihood values And points N)r9Úextendr8Úlenr:Ú history_save)r%ÚloglsrFr'r'r(rEÀs  zLogLikelihood.history_appendc CsŒtdkrtdƒ‚d|_yRtj|jdd8}|jd|j|jfd|jfd|jd|jfd dWdQRXWntk r†t d ƒ‚YnXdS) z, Initialize the hdf5 storage of evaluations Nz3h5py module is required for saving history of callsrÚw)ÚmodeÚparam)ZmaxshapeÚlogl)Nz!Failed to initialize history file) Úh5pyÚ RuntimeErrorÚhistory_counterÚFiler<Zcreate_datasetr:r=ÚOSErrorÚprint)r%Úfpr'r'r(r?Ês zLogLikelihood.history_initc Csê|js |jsdSy°tj|jdd–}t|jƒ}|dj|j|dd|dj|j|ddt   |j ¡|d| d…dd…f<t   |j¡|d| d…<g|_ g|_|j|7_WdQRXWn$t k rät  d¡d |_YnXdS) zO Save the actual history from an internal buffer into the file NÚa)rOrPr)ÚaxisrQz:Failed to save history of evaluations. Will not try again.T)r>r;rRrUr<rKr9ÚresizerTÚnpÚarrayr8rVÚwarningsÚwarn)r%rXÚnaddr'r'r(rLÚs   "zLogLikelihood.history_savecCs|j ¡}d|kr|d=|S)z#Get state information for pickling.r7)Ú__dict__Úcopy)r%Ústater'r'r(Ú __getstate__òs zLogLikelihood.__getstate__)NFNF) r2r3r4r5r)rDrIrEr?rLrdr'r'r'r(rvs   c@s:eZdZdZddd„Zdd„Zdd„Zd d „Zd d „Zd S)rz› This is the dictionary like class that saves the results of the nested run so it is basically a collection of various lists of quantities FcCs\i}ddddddddd d d d d dddg}|r<| dddg¡x|D] }g||<qBW||_dS)z^ If dynamic is true. We initialize the class for a dynamic nested run ÚidÚur&rQrrrrrrrÚitÚnrÚscaler"ÚbatchÚ batch_nliveÚ batch_boundsN)rJÚD)r%ZdynamicrmÚkeysÚkr'r'r(r)s2  zRunRecord.__init__cCs*x$| ¡D]}|j| ||¡q WdS)zƒ append new information to the RunRecord in the form a dictionary i.e. run.append(dict(batch=3, niter=44)) N)rnrmÚappend)r%ZnewDror'r'r(rp%szRunRecord.appendcCs |j|S)N)rm)r%ror'r'r(Ú __getitem__-szRunRecord.__getitem__cCs||j|<dS)N)rm)r%ror&r'r'r(Ú __setitem__0szRunRecord.__setitem__cCs |j ¡S)N)rmrn)r%r'r'r(rn3szRunRecord.keysN)F) r2r3r4r5r)rprqrrrnr'r'r'r(rús  $c@s eZdZdZdd„Zdd„ZdS)rzE Utility class that allows us to detect a certain time has passedcCs||_t ¡|_dS)z¢ Initialise the time with delay of dt seconds Parameters ---------- delay: float The number of seconds in the timer N)ÚdelayÚtimeÚ last_time)r%rsr'r'r(r);s zDelayTimer.__init__cCs&t ¡}||j|jkr"||_dSdS)a? Returns true if more than self.dt seconds has passed since the initialization or last call of successful is_time() Returns ------- ret: bool True if specified amout of time has passed since the initialization or last successful is_time() call TF)rtrurs)r%Zcurtr'r'r(Úis_timeGs zDelayTimer.is_timeN)r2r3r4r5r)rvr'r'r'r(r7s Ú PrintFnArgsÚniterÚ short_strÚmid_strÚlong_strc CsD| dkr$t|||||||||d nt| |||||||||d dS)aú The default function used to print out results in real time. Parameters ---------- results : tuple Collection of variables output from the current state of the sampler. Currently includes: (1) particle index, (2) unit cube position, (3) parameter position, (4) ln(likelihood), (5) ln(volume), (6) ln(weight), (7) ln(evidence), (8) Var[ln(evidence)], (9) information, (10) number of (current) function calls, (11) iteration when the point was originally proposed, (12) index of the bounding object originally proposed from, (13) index of the bounding object active at a given iteration, (14) cumulative efficiency, and (15) estimated remaining ln(evidence). niter : int The current iteration of the sampler. ncall : int The total number of function calls at the current iteration. add_live_it : int, optional If the last set of live points are being added explicitly, this quantity tracks the sorted index of the current live point being added. dlogz : float, optional The evidence stopping criterion. If not provided, the provided stopping value will be used instead. stop_val : float, optional The current stopping criterion (for dynamic nested sampling). Used if the `dlogz` value is not specified. nbatch : int, optional The current batch (for dynamic nested sampling). logl_min : float, optional The minimum log-likelihood used when starting sampling. Default is `-np.inf`. logl_max : float, optional The maximum log-likelihood used when stopping sampling. Default is `np.inf`. N)Ú add_live_itÚdlogzÚstop_valÚnbatchÚlogl_minÚlogl_max)Úprint_fn_fallbackÚ print_fn_tqdm) ÚresultsrxÚncallr|r}r~rr€rÚpbarr'r'r(Úprint_fn]s(A r‡c Cs¸|j} |j} |j} |j} |j} |j}|j}| dkr8tj} | dkrT| dkrTt  | ¡}ntj }| dkrjtj } | dkrztj } g}|dk r–|  d  |¡¡t |ƒ}|dk r¶|  d  |¡¡|  d  | ¡¡|  d  |¡¡|  d  |¡¡|  d   |¡¡|  |d ¡|  d   || |¡¡|  d   || |¡¡|  d   | |¡¡|  d  | |¡¡t |ƒ}|dk rˆ|  d  | |¡¡|  d  | |¡¡n |  d  |¡¡|  d  |¡¡t||||dS)Ng€„.Agg€„.Áz+{:d}z batch: {:d}z bound: {:d}znc: {:d}z ncall: {:d}zeff(%): {:6.3f}éÿÿÿÿz%loglstar: {:6.3f} < {:6.3f} < {:6.3f}zlogl*: {:6.1f}<{:6.1f}<{:6.1f}zlogz: {:6.3f} +/- {:6.3f}zlogz: {:6.1f}+/-{:.1f}zdlogz: {:6.3f} > {:6.3f}zdlogz: {:6.1f}>{:6.1f}z stop: {:6.3f})rxryrzr{)rrrr!rrr r\ÚinfÚsqrtÚnanrpÚformatrCrw)r„rxr…r|r}r~rr€rrrrr!rrr Úlogzerrr{ryrzr'r'r(Úget_print_fn_argsµsV     rŽc CsFt||||||||| d } |jd | j¡dd| | j|j¡dS)zL This is a function that does the status printing using tqdm module )r|r}r~rr€rz | F)ÚrefreshN)rŽZset_postfix_strÚjoinr{Úupdaterxrh) r†r„rxr…r|r}r~rr€rÚfn_argsr'r'r(rƒôs rƒc  Cs$t|||||||||d } | j| j| j| jf\}} } } d |¡g| } d | ¡} d | ¡} d | ¡} tj  ¡rŠt t dƒrŠt j ddd} nd } | t | ƒkrÀtj d | d | t | ƒd ¡nV| t | ƒkròtj d | d | t | ƒd ¡n$tj d | d | t | ƒd ¡tj ¡d S)zl This is a function that does the status printing using just standard printing into the console )r|r}r~rr€rz iter: {:d}z | ú|Úget_terminal_size)éPé)ÚfallbackréÈú ú éN)rŽrxryrzr{rŒrÚsysÚstderrÚisattyÚhasattrÚshutilr”rKÚwriteÚflush)r„rxr…r|r}r~rr€rr’ryrzr{Úcolumnsr'r'r(r‚s2     & &r‚)rQz array[float]zLog likelihoodrx)Ú samples_itz array[int]zIthe sampling iteration when the sample was proposed (e.g., iteration 570)rx)Ú samples_idz array[int]z5The unique ID of the sample XXX (within nlive points)N)Ú samples_nz array[int]zCThe number of live points at the point when the sample was proposedrx)Ú samples_uz array[float]zEThe coordinates of live points in the unit cube coordinate systemz niter,ndim)Z samples_vz array[float]zThe coordinates of live pointsz niter,ndim)Úsamplesr]z>the location (in original coordinates). Identical to samples_vz niter,ndim)rxÚintznumber of iterationsN)r…r©zTotal number likelihood callsN)rr]z$Array of cumulative log(Z) integralsrx)rr]zArray of uncertainty of log(Z)rx)rr]zArray of log-posterior weightsrx)r r*zSampling efficiencyN)Únliver©z&Number of live points for a static runN)rz array[float]zLogvolumes of dead pointsrx)Ú informationz array[float]zInformation Integral Hrx)Úboundz array[object]zHthe set of bounding objects used to condition proposals for the base runZnbound)Z bound_iterz array[int]zGindex of the bound being used for an iteration that generated the pointrx)Z samples_boundz array[int]zCThe index of the bound that the corresponding sample was drawn fromrx)Ú samples_batchz array[int]z7Tracks the batch during which the samples were proposedrx)rlz array[tuple]z.The log-likelihood bounds used to run a batch.r)rkz array[int]z/The number of live points used for given batchr)riz array[float]z"Scalar scale applied for proposalsrx)r"zarray[]z;The auxiliary blobs computed by the log-likelihood functionrxcsœeZdZdZedd„eDƒƒZdd„Zdd„Zdd „Z ‡fd d „Z d d „Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zd!dd„Zdd „Z‡ZS)"ÚResultsa  Contains the full output of a run along with a set of helper functions for summarizing the output. The object is meant to be unchangeable record of the static or dynamic nested run. Results attributes (name, type, description, array size): cCsg|] }|d‘qS)rr')r@rAr'r'r(rBvszResults.cCsÚg|_d|_t|tƒr | ¡}n|}xN|D]F\}}||jks@t‚|tjksRt|ƒ‚|j |¡t ||t   |¡ƒq*Wddddg}x"|D]}||jkr†t d|ƒ‚q†Wd|jkr¶d|_ nd|jkrÈd |_ nt d ƒ‚d |_d S) zÛ Initialize the results using the list of key value pairs or a dictionary Results([('logl', [1, 2, 3]), ('samples_it',[1,2,3])]) Results(dict(logl=[1, 2, 3], samples_it=[1,2,3])) Fr§r¥rQr¨zKey %s must be providedrªr¦TzITrying to construct results object without nlive or samples_n informationN) Ú_keysÚ _initializedÚ isinstanceÚdictÚitemsÚAssertionErrorr®Ú_ALLOWEDrpÚsetattrrbÚ ValueErrorÚ_dynamic)r%Ú key_valuesZkey_values_listror&Ú required_keysr'r'r(r)xs*        zResults.__init__cCst| ¡ ¡ƒS)N)r®Úasdictr³)r%r'r'r(Ú__copy__šszResults.__copy__cCs| ¡S)zY return a copy of the object all numpy arrays will be copied too )r¼)r%r'r'r(rbžsz Results.copycs,|ddkr|jrtdƒ‚tƒ ||¡dS)NrrAzCannot set attributes directly)r°rSÚsuperÚ __setattr__)r%ÚnameÚvalue)Ú __class__r'r(r¾¥szResults.__setattr__cCs ||jkrt||ƒSt|ƒ‚dS)N)r¯ÚgetattrÚKeyError)r%r¿r'r'r(rqªs  zResults.__getitem__cs8tttttˆjƒƒƒƒd‰d ‡‡fdd„ˆjDƒ¡S)NrÚ cs(g|] }| ˆ¡dttˆ|ƒƒ‘qS)z: )ÚrjustÚreprrÂ)r@ro)Úmr%r'r(rB³sz$Results.__repr__..)ÚmaxrCrDrKr¯r)r%r')rÇr%r(Ú__repr__°szResults.__repr__cCs ||jkS)N)r¯)r%Úkeyr'r'r(Ú __contains__µszResults.__contains__cCs|jS)z6 Return the list of attributes/keys stored in Results )r¯)r%r'r'r(rn¸sz Results.keyscs‡fdd„ˆjDƒS)zS Return the list of items in the results object as list of key,value pairs c3s|]}|tˆ|ƒfVqdS)N)rÂ)r@ro)r%r'r(ú Àsz Results.items..)r¯)r%r')r%r(r³¼sz Results.itemscst‡fdd„ˆjDƒƒS)zE Return contents of the Results object as dictionary c3s"|]}|t tˆ|ƒ¡fVqdS)N)rbrÂ)r@ro)r%r'r(rÌÇsz!Results.asdict..)r²r¯)r%r')r%r(r»ÂszResults.asdictcCs|jS)z Return true if the results was constructed using dynamic nested sampling run with (potentially) variable number of live-points)r¸)r%r'r'r(Ú isdynamicÉszResults.isdynamiccCs.|d|dd}t |¡}|| ¡}|S)zD Return the importance weights for the each sample. rrrˆ)r\ÚexpÚsum)r%rÚwtr'r'r(Úimportance_weightsÏs  zResults.importance_weightsNcCs$|dkrtƒ}t|d| ¡|dS)zF Return the equally weighted samples in random order. Nr¨)Úrstate)Úget_random_generatorrrÑ)r%rÒr'r'r(Ú samples_equalØs zResults.samples_equalc Cs†|jr| ¡D]2\}}||kr.| ||f¡q| |||f¡qWt|ƒS)zx This is an utility method that takes a Result object and substituted certain keys in it. It returns a copy object! )r³rpr®)r„Zkw_dictZnew_listrorNr'r'r(Úresults_substitutes rÛcCs¦d}d}|dk r,|dkr,|dks$t‚|dfS|dkrX|dk rX|dksP|dksPt‚d|fS|dkr‚|dkr‚|dkrxd|fS|dfSn |dks’|dkrš||fStdƒ‚dS)z: Determine the enlarge, bootstrap for a given run gô?éNrrZunifzREnlarge and bootstrap together do not make sense unless bootstrap=0 or enlarge = 1)r´r·)ÚsampleZenlargeZ bootstrapZDEFAULT_ENLARGEZDEFAULT_UNIF_BOOTSTRAPr'r'r(rs  cCsœ|dk r(|dk r(t ||¡dkr(tdƒ‚|dk s8|dk r”tj|td}|dk rlt |¡|krdtdƒ‚d||<|dk r˜t |¡|krŠtdƒ‚d||<nd}|S)z¥ Return a boolean mask for dimensions that are either periodic or reflective. It will be true for normal dimension and false for periodic/reflective Nrz?You have specified a parameter as both periodic and reflective.)Údtypez3Incorrect periodic variable index (larger than ndimF)r\Z intersect1dr·ÚonesÚboolrÈ)r=ZperiodicZ reflectiveÚ nonboundedr'r'r(Úget_nonbounded1s" râcCs:d}|dkr2tdks|st}nt ¡}tt|d}||fS)N)r†)Útqdmr‡r)Z print_funcÚprint_progressr†r'r'r(Úget_print_funcNs  råcCs&t|tjjƒr|Stj tj |¡¡S)zJ Return a random generator (using the seed provided if available) )r±r\ÚrandomÚ GeneratorZPCG64)Úseedr'r'r(rÓYsrÓcCs"tj |jdddd¡ |¡}|S)zz Return the list of seeds to initialize random generators This is useful when distributing work across a pool rlÿÿÿÿé)Úsize)r\ræZ SeedSequenceÚintegersÚspawn)rÒZnitemsÚseedsr'r'r(Úget_seed_sequencebsrîcCs*t || ¡¡}| ¡d|d ¡S)a7 Compute the number of effective samples from an array of unnormalized log-weights. We use Kish Effective Sample Size (ESS) formula. Parameters ---------- logwt: numpy array Array of unnormalized weights Returns ------- int The effective number of samples r›)r\rÎrÈrÏ)rÚWr'r'r(Úget_neff_from_logwtlsrðcCsf|dkr | ¡dko| ¡dkS||}||}| ¡dko`| ¡dko`| ¡dko`| ¡dkSdS)z™Check whether `u` is inside the unit cube. Given a masked array `nonbounded`, also allows periodic boundaries conditions to exceed the unit cube.Nrrgà¿gø?)ÚminrÈ)rfráZunbZubr'r'r(r„s  $cCsDt |d¡dk}t ||d¡||<dt ||d¡||<|S)a Iteratively reflect a number until it is contained in [0, 1]. This is for priors with a reflective boundary condition, all numbers in the set `u = 2n +/- x` should be mapped to x. For the `+` case we just take `u % 1`. For the `-` case we take `1 - (u % 1)`. E.g., -0.9, 1.1, and 2.9 should all map to 0.9. Parameters ---------- u: array-like The array of points to map to the unit cube Returns ------- u: array-like The input array, modified in place. r›r)r\Úmod)rfZ idxs_evenr'r'r(Ú apply_reflect•srócCsXtj||dd}||}t |¡}t |d¡}||d|t d|||¡}||fS)a• Compute the weighted mean and covariance of the samples. Parameters ---------- samples : `~numpy.ndarray` with shape (nsamples, ndim) 2-D array containing data samples. This ordering is equivalent to using `rowvar=False` in `~numpy.cov`. weights : `~numpy.ndarray` with shape (nsamples,) 1-D array of sample weights. Returns ------- mean : `~numpy.ndarray` with shape (ndim,) Weighted sample mean vector. cov : `~numpy.ndarray` with shape (ndim, ndim) Weighted sample covariance matrix. Notes ----- Implements the formulae found `here `_. r)ÚweightsrZr›zi,ij,ik)r\ZaveragerÏZeinsum)r¨rôÚmeanZdxZwsumZw2sumZcovr'r'r(r ±s   c Cs¼|dkrtƒ}t |¡}t|ddƒtkr6t d¡||d}t|ƒ}| ¡t  |¡|}tj |t d}d\}}x6||kr¬||||kr¢|||<|d7}qx|d7}qxW|  ||¡S)aâ Resample a set of points from the weighted set of inputs such that they all have equal weight. The points are also randomly shuffled. Each input sample appears in the output array either `floor(weights[i] * nsamples)` or `ceil(weights[i] * nsamples)` times, with `floor` or `ceil` randomly selected (weighted by proximity). Parameters ---------- samples : `~numpy.ndarray` with shape (nsamples,) Set of unequally weighted samples. weights : `~numpy.ndarray` with shape (nsamples,) Corresponding weight of each sample. rstate : `~numpy.random.Generator`, optional `~numpy.random.Generator` instance. Returns ------- equal_weight_samples : `~numpy.ndarray` with shape (nsamples,) New set of samples with equal weights in random order. Examples -------- >>> x = np.array([[1., 1.], [2., 2.], [3., 3.], [4., 4.]]) >>> w = np.array([0.6, 0.2, 0.15, 0.05]) >>> utils.resample_equal(x, w) array([[ 1., 1.], [ 1., 1.], [ 1., 1.], [ 3., 3.]]) Notes ----- Implements the systematic resampling method described in `Hol, Schon, and Gustafsson (2006) `_. Nrˆgð?z3Weights do not sum to 1 and have been renormalized.)rÞ)rrr) rÓr\ÚcumsumÚabsÚSQRTEPSr^r_rKræÚarangeÚzerosr©Z permutation) r¨rôrÒZcumulative_sumZnsamplesZ positionsÚidxÚiÚjr'r'r(rØs *      cCsÐt |¡}t |¡}t |dk¡s0t |dk¡r8tdƒ‚|dkrTt |td|ƒ¡St |¡}t|ƒt|ƒkrvtdƒ‚t |¡}||}t |¡dd…}||d}t  d|¡}t  ||||¡  ¡}|SdS) a Compute (weighted) quantiles from an input set of samples. Parameters ---------- x : `~numpy.ndarray` with shape (nsamps,) Input samples. q : `~numpy.ndarray` with shape (nquantiles,) The list of quantiles to compute from `[0., 1.]`. weights : `~numpy.ndarray` with shape (nsamps,), optional The associated weight from each sample. Returns ------- quantiles : `~numpy.ndarray` with shape (nquantiles,) The weighted sample quantiles computed at `q`. ggð?z#Quantiles must be between 0. and 1.NgY@z+Dimension mismatch: len(weights) != len(x).rˆr) r\Z atleast_1dÚanyr·Z percentilerCrKÚargsortrörpZinterpÚtolist)rHÚqrôrûÚswZcdfZ quantilesr'r'r(r s       cCs~| ¡r|j}t|ƒ}n^|j}|j}t|jƒ}||krJtj|td|}n,|||krnt  t  |dd¡|¡}nt dƒ‚||fS)aš Helper function for calculating the number of samples Parameters ---------- res : :class:`~dynesty.results.Results` instance The :class:`~dynesty.results.Results` instance taken from a previous nested sampling run. Returns ------- nsamps: int The total number of samples/iterations samples_n: array Number of live points at a given iteration )rÞrrˆzTFinal number of samples differs from number of iterations and number of live points.) rÍr¦rKrxrªrr\rßr©Úminimumrùr·)rÕr¦Únsampsrxrªr'r'r(Ú_get_nsamps_samples_nMs   rc Csøt|ƒ}tj|td}gg}}t |¡dk|dd…<t |¡d}t|ƒdkrì|dd}|d}| ||¡x\|dd…D]L}||dkrœ|d7}q€q€| ||dg¡| ||d¡|}|d}q€W| ||df¡t |¡}|||fS)a“ Find all instances where the number of live points is either constant or increasing. Return the mask, the values of nlive when nlives starts to decrease The ranges of decreasing nlives v=[3,2,1,13,13,12,23,22]; > print(dynesty.utils._find_decrease(v)) (array([ True, False, False, True, True, False, True, False]), [3, 13, 23], [[0, 3], [4, 6], (6, 8)]) )rÞrrN)rKr\rúràÚdiffZnonzerorpr]) r¦rÚ nlive_flagÚ nlive_startÚboundsÚidsZboundlÚlastZcurir'r'r(Ú_find_decreaseqs(      r Fc Cs^|dkrtƒ}t|ƒ\}}|j}|r>tj|td}gg}}nt|ƒ\}}}t |¡} |j||dd| |<t |ƒ} xšt | ƒD]Ž} || } || } || d| d…}|j d| dd}|  ¡}||d}|t  | |d¡}|dd…|dd…}|| | d| d…<q~Wt | ¡  ¡}t||d \}}}}|||t t |d¡¡|d œ}t||ƒ}|S) a™ Probes **statistical uncertainties** on a nested sampling run by explicitly generating a *realization* of the prior volume associated with each sample (dead point). Companion function to :meth:`resample_run`. Parameters ---------- res : :class:`~dynesty.results.Results` instance The :class:`~dynesty.results.Results` instance taken from a previous nested sampling run. rstate : `~numpy.random.Generator`, optional `~numpy.random.Generator` instance. approx : bool, optional Whether to approximate all sets of uniform order statistics by their associated marginals (from the Beta distribution). Default is `False`. Returns ------- new_res : :class:`~dynesty.results.Results` instance A new :class:`~dynesty.results.Results` instance with corresponding weights based on our "jittered" prior volume realizations. N)rÞr)rYÚbrgð?)rirêrˆ)rQr)rrrrr)rÓrrQr\rßràr rúÚbetarKÚrangeZ exponentialrörpÚlogÚcompute_integralsrŠÚmaximumrÛ)rÕrÒÚapproxrr¦rQrrr Zt_arrZnunifrüZnstartr¬ZsnZy_arrZycsumZuorderZrorderrÚ saved_logwtÚ saved_logzÚ saved_logzvarÚsaved_hÚ substituteÚnew_resr'r'r(r s<       cCsH|dk s t‚|dk st‚t dg|g¡}tj|dd}||t t |¡ ¡}|t d¡}tj|dd }t |dd…|dd…¡|}|dk rž||}tj  |¡}|d} t  t |dd…| |¡|dd…t |dd…| |¡|dd…¡} | | t || ¡} tj| dd} t  t  | |¡¡} ||| | fS)aG Compute weights, logzs and variances using quadratic estimator. Returns logwt, logz, logzvar, h Parameters: ----------- logl: array array of log likelihoods logvol: array array of log volumes reweight: array (or None) (optional) reweighting array to reweight posterior Ngœuˆ<ä7þr)Úprependgà?rrˆ) r´r\Ú concatenaterÚlog1prÎÚmathrÚ logaddexpÚ accumulaterör÷)rQrÚreweightZ loglstar_padÚdlogvolÚlogdvolZlogdvol2rrZlogzmaxZh_part1rÚdhrr'r'r(rûs&    $*rcCsžt|||gddgd}t ||¡|}t ||¡} t || |¡|t || |¡|} | t || ¡||| } | |} || |} || | | fS)a  This is the calculation of weights and logz/var estimates one step at the time. Importantly the calculation of H is somewhat different from compute_integrals as incomplete integrals of H() of require knowing Z Return logwt, logz, logzvar, h gà?gà¿)rYr )rr\rrrÎ)rZ loglstar_newrrrr!rr"rZlogz_newZlztermZh_newr#Z logzvar_newr'r'r(Úprogress_integration:s   r$c+sò|dkrtƒ}tˆjƒ}ˆ ¡r8ˆj}ˆj}ˆj}d}n„ˆj}ˆj} || krdt j | t d|}d}n0|| |krŒt   t   |dd¡|¡}d}ntdƒ‚t jt|ƒt d}t  t j t jfg¡}|dd…df} t  ˆj¡} g} g} xH| D]@}|ˆj|k}t  | |t j k¡r|  |¡qæ|  |¡qæWt| ƒt| ƒ}}t  | ¡t  | ¡} } |dkr”|dkr”t  | |jd||d| |jd||d¡}n<|dkr´| |jd||d}n|dkrÈtd ƒ‚ntd ƒ‚t   tˆjƒ¡‰t  ‡‡fd d „|Dƒ¡‰tˆƒ}ˆjˆ}t  |¡}ˆ|‰ˆjˆ}|rt j|t d}t j|dd \}}x¾t||ƒD]¦\}}ˆj|k}||d}| |}tˆj|ƒ}|||k||k@|7<||k}t  |¡}||} t jt   |¡| t d}!|!ddd…d}"|||"7<qZWn|ˆ}t  t  ||d¡¡}#t||#d\}$}%}&}'dtˆjˆƒt ˆjˆƒ}(t!tˆjˆƒˆjˆ|(ˆj"ˆˆj#ˆˆjˆˆj$ˆˆj%ˆ|t  &|$¡||#t  &|%¡t  't  (t  &|&¡d¡¡t  &|'¡d})t)|)ƒ}*|rê|*ˆfS|*SdS)aœ Probes **sampling uncertainties** on a nested sampling run using bootstrap resampling techniques to generate a *realization* of the (expected) prior volume(s) associated with each sample (dead point). This effectively splits a nested sampling run with `K` particles (live points) into a series of `K` "strands" (i.e. runs with a single live point) which are then bootstrapped to construct a new "resampled" run. Companion function to :meth:`jitter_run`. Parameters ---------- res : :class:`~dynesty.results.Results` instance The :class:`~dynesty.results.Results` instance taken from a previous nested sampling run. rstate : `~numpy.random.Generator`, optional `~numpy.random.Generator` instance. return_idx : bool, optional Whether to return the list of resampled indices used to construct the new run. Default is `False`. Returns ------- new_res : :class:`~dynesty.results.Results` instance A new :class:`~dynesty.results.Results` instance with corresponding samples and weights based on our "bootstrapped" samples and (expected) prior volumes. NT)rÞFrrˆzTFinal number of samples differs from number of iterations and number of live points.)rêzTThe provided `Results` does not include any points initially sampled from the prior!z=The provided `Results` does not appear to have any particles!csg|]}ˆˆj|k‘qSr')r¥)r@rû)rÕÚsamp_idxr'r(rB²sz resample_run..)Z return_countsrgð?)rQrgY@)rxr…r r"r¨r¥r¤r§r¦rrQrrrr«)*rÓrKr…rÍr¦r­rlrªrxr\rßr©rrùr·rúr]r‰Úuniquer¥rþrprërrQrÿÚziprÈZ count_nonzerorörrrÏr²r"r¨r¤r§ÚasarrayrŠrr®)+rÕrÒÚ return_idxrr¦r­rlZadded_final_liverªrxZ batch_llminr Zbase_idsZ addon_idsrüÚsbatchÚnbaser`Zlive_idxrMZidx_sortrQZsamp_nZuidxsZuidxs_nZuidxZuidx_nÚselÚlowerÚupperZendselZendsel_nÚchunkZcountersZ nlive_endrrrrrr Z new_res_dictrr')rÕr%r(r Ss¬                c Csj|dkr|d}||}|d}|d}t|||d\}}}} |||t t |d¡¡| dœ} t|| ƒ} | S)a Reweight a given run based on a new target distribution. Parameters ---------- res : :class:`~dynesty.results.Results` instance The :class:`~dynesty.results.Results` instance taken from a previous nested sampling run. logp_new : `~numpy.ndarray` with shape (nsamps,) New target distribution evaluated at the location of the samples. logp_old : `~numpy.ndarray` with shape (nsamps,) Old target distribution evaluated at the location of the samples. If not provided, the `logl` values from `res` will be used. Returns ------- new_res : :class:`~dynesty.results.Results` instance A new :class:`~dynesty.results.Results` instance with corresponding weights based on our reweighted samples. NrQr)rQrr r)rrrrr)rr\rŠrrÛ) rÕZlogp_newZlogp_oldZlogrwtrrQrrrrrrr'r'r(r ûs TcCs|j}d}yt|ƒ|j|jkr$d}Wntk r:YnXt |j¡dk ¡dkr^t   d¡g}tt  |¡ƒ}x–t t  |¡ƒD]‚\}}||k}t|ƒ} |j|} |r | d} t  d¡ dt | ¡} | dkrö| dt  d ¡} t | | ¡}nt t  d ¡g¡}n| } t  d¡ dt | ¡}t| |d \}}}}d | t|j|ƒ}td| |j|||j||j||j||j||j||| ||t |¡|d }y|j||d <|j|d<Wntk rÔYnX| t|ƒ¡|r‚tj d|d›d|›d¡q‚W|S)a Unravels a run with `K` live points into `K` "strands" (a nested sampling run with only 1 live point). **WARNING: the anciliary quantities provided with each unraveled "strand" are only valid if the point was initialized from the prior.** Parameters ---------- res : :class:`~dynesty.results.Results` instance The :class:`~dynesty.results.Results` instance taken from a previous nested sampling run. print_progress : bool, optional Whether to output the current progress to `~sys.stderr`. Default is `True`. Returns ------- new_res : list of :class:`~dynesty.results.Results` instances A list of new :class:`~dynesty.results.Results` instances for each individual strand. TFrzPThe likelihood seem to have plateaus. The unraveling such runs may be inaccuraterr›gð?rˆgà?)rQrgY@)rªrxr…r r¨r¥r¤r§r"rrQrrrr«r­rlz Strand: ú/z ) r¥rKrxrªÚAttributeErrorr\rrQrÏr^r_r&Ú enumeraterrrùrpr]rr…r²r¨r¤r§r"rŠr­rlr®rœrr¡)rÕräZidxsZ added_liverZnstrandsÚcounterrûZstrandrrQrxZ logvol_deadZ logvol_liverrrrrr Zrdictr'r'r(r+sf  "c Cst|ƒ}d}g}g}xV|D]N}y*t |jdk¡r<| |¡n | |¡Wqtk rf| |¡YqXqWt|ƒt|ƒ}}|dkr–|dkr–|}g}t|ƒdkr€xÂt|ƒdkrfg} t|ƒ} d} x”| | krXy2|| || d} } t| | dd}|  |¡Wn$tk r&|  || ¡YnX| d7} |d7}|rÆtj   d|›d|›d¡qÆWt   | ¡}q¦Wt|d|dd d}n|d}t|ƒ} xjt |ƒD]^\} }| | dkrÀt||dd}nt||d d}|d7}|rštj   d|›d|›d¡qšWt |ƒ}|S) aU Merges a set of runs with differing (possibly variable) numbers of live points into one run. Parameters ---------- res_list : list of :class:`~dynesty.results.Results` instances A list of :class:`~dynesty.results.Results` instances returned from previous runs. print_progress : bool, optional Whether to output the current progress to `~sys.stderr`. Default is `True`. Returns ------- combined_res : :class:`~dynesty.results.Results` instance The :class:`~dynesty.results.Results` instance for the combined run. rrr›F)Ú compute_auxz Merge: r0z T)rKr\rþr­rpr1Ú _merge_twoÚ IndexErrorrœrr¡rbr2Úcheck_result_static)Zres_listräÚntotr3Z rlist_baseZ rlist_addÚrr+r`Z rlist_newZnrunsrüÚr1Úr2rÕr'r'r(r•sX    cCs˜t|ƒd}t|ƒ}|j}d}|j|kr:t ||k¡r:d}t t |dd¡|¡}|j|krlt ||k¡rld}|r”| ¡}||d<|||d<t |ƒ}|S)zª If the run was from a dynamic run but had constant number of live points, return a new Results object with nlive parameter, so we could use it as static run rFTrrˆrªrx) rrÈrxrêr\Úallrrùr»r®)rÕr¦rªrxZ standard_runZ nlive_testZresdictr'r'r(r7ës  r7Újitterc Cs”|j|jd}|dkr(t|||d}n,|dkrLt||dd\}}||}ntdƒ‚|d|d d}t t |¡||¡} |rŒ| |fS| Sd S) a½ Computes the `Kullback-Leibler (KL) divergence `_ *from* the discrete probability distribution defined by `res` *to* the discrete probability distribution defined by a **realization** of `res`. Parameters ---------- res : :class:`~dynesty.results.Results` instance :class:`~dynesty.results.Results` instance for the distribution we are computing the KL divergence *from*. error : {`'jitter'`, `'resample'`}, optional The error method employed, corresponding to :meth:`jitter_run` or :meth:`resample_run`. Default is `'jitter'`. rstate : `~numpy.random.Generator`, optional `~numpy.random.Generator` instance. return_new : bool, optional Whether to return the realization of the run used to compute the KL divergence. Default is `False`. approx : bool, optional Whether to approximate all sets of uniform order statistics by their associated marginals (from the Beta distribution). Default is `False`. Returns ------- kld : `~numpy.ndarray` with shape (nsamps,) The cumulative KL divergence defined *from* `res` *to* a random realization of `res`. new_res : :class:`~dynesty.results.Results` instance, optional The :class:`~dynesty.results.Results` instance corresponding to the random realization we computed the KL divergence *to*. rˆr=)rÒrÚresampleT)rÒr)z.Input `'error'` option '{error}' is not valid.rrN)rrr r r·r\rörÎ) rÕÚerrorrÒÚ return_newrZlogp2rr%Zlogp1Úkldr'r'r(rs- c(st|j|j|j|j|j|j|jd}t|dƒ}|  ¡r@|j }nV|j |j }}||krjt j|td|}n,|||krŽt  t  |dd¡|¡}ntdƒ‚|  ¡sªd| ¡krÀ|j|d<|j|d <n,t j|td|d<t  t j t jfg¡|d <t|j|j|j|j|j|j|jd}t|dƒ} |  ¡r.|j } nZ|j |j }}| |krZt j|td|} n.| ||kr€t  t  | dd¡|¡} ntd ƒ‚|  ¡s d| ¡kr¶|j|d<|j|d <n,t j| td|d<t  t j t jfg¡|d <tggggggggggggggd ‰t  |d |d k¡r,|d } d} n"t  |d |d f¡} t|d ƒ} d \} }|d | |d |}}|| | |}}|| }t  |d |d¡}t  |d |d¡}xJt|ƒD]<}||kræ||kræ||}n||krö|}n|}||kr,| }|}| d7} ˆd |d|¡n*|}|}|d7}ˆd |d|| ¡x$dD]}ˆ| |||¡q\Wˆd |¡y|d | }|| }Wn tk rÂt j}d}YnXy|d |}| |}Wn tk rüt j}d}YnXqÂWd}d}d}d}t  ˆd ¡}t  ˆd¡}xÈtt ||ƒƒD]¶\}\} }|s’||d…| k}!|! !¡}"|"dkr’|"}|t  "d|d¡}d}|s°|t# "|d|¡8}n|t  $t  %||¡ ¡}ˆd |¡|r@|d8}|dkr@d}q@Wd|t!ˆdƒ}#t|t  &ˆd¡|#t  &ˆd¡t  &ˆd ¡t  &ˆd¡t  &| ¡t  &ˆd¡d}$x$dD]}t  &ˆ|¡|$d|<qdW|rt'|$d|$d d\|$d<|$d<}%|$d <t  (t  )|%d¡¡|$d!<t  &ˆd¡‰‡‡fd"d#„t  *ˆd¡Dƒ}&t j|&td|$d$<t+|$ƒ}'|'S)%a7 Internal method used to merges two runs with differing (possibly variable) numbers of live points into one run. Parameters ---------- res1 : :class:`~dynesty.results.Results` instance The "base" nested sampling run. res2 : :class:`~dynesty.results.Results` instance The "new" nested sampling run. compute_aux : bool, optional Whether to compute auxiliary quantities (evidences, etc.) associated with a given run. **WARNING: these are only valid if `res1` or `res2` was initialized from the prior *and* their sampling bounds overlap.** Default is `False`. Returns ------- res : :class:`~dynesty.results.Results` instances :class:`~dynesty.results.Results` instance from the newly combined nested sampling run. )rerfr&rQrrgr"re)rÞrrˆz^Final number of samples differs from number of iterations and number of live points in `res1`.rlrjr z^Final number of samples differs from number of iterations and number of live points in `res2`.)rerfr&rQrrrrrrrgrhrjr")rrrQrrhFgNgð?TrgY@rr&r")rxr…r r¨rQrrlr")rergrhrfrjZsamples_)rrQrrr«rcs&g|]}tt ˆˆd|k¡ƒ‘qS)rj)rKr\r&)r@rü)Ú combined_idÚ combined_infor'r(rB5sz_merge_two..rk),r²r¥r§r¨rQr…r¤r"rKrÍr¦rxrªr\rßr©rrùr·rnr­rlrúr]r‰r<rrñrrpr6r2r'rÏrrrrÎr(rrŠrr&r®)(Zres1Zres2r4Z base_infor+Zbase_nrxrªZnew_infoZnnewZnew_nr ZboffsetZidx_baseZidx_newZlogl_bZlogl_nZnlive_bZnlive_nr8Zllmin_bZllmin_nrüZadd_idxZfrom_runZcurkZ plateau_modeZplateau_counterZplateau_logdvolrZ logl_arrayZ nlive_arrayZcurlZ plateau_maskZnplateaur r9Zcombined_logzvarrkrÕr')rBrCr(r5Ls                               r5cCs&|\}}}}t|ƒ}t|||d|dS)zb Internal `pool.map`-friendly wrapper for :meth:`kld_error` used by :meth:`stopping_function`.T)rÒr@r)rÓr)Úargsr„r?rZrseedrÒr'r'r(Ú _kld_errorBs rEc s0t ¡t d¡t dt¡WdQRX|dkr6i}|dkrBt}| dd¡}d|krbdkstntd|›dƒ‚| d d ¡}|dkr¦|dkr¦td |›d |›d ƒ‚| dd¡}|dkrØ|dkrØtd|›d |›d ƒ‚| dd¡}|dkrütd|›dƒ‚|dkrt d¡| dd¡‰ˆdkr6tdˆ›dƒ‚| dd¡‰‡fdd „t|ƒDƒ} ‡fd!d „t|ƒDƒ} ‡fd"d „t|ƒDƒ} t ||ƒ} t | | | | ƒ}t |t |ƒƒ} t  d#d „| Dƒ¡j\}}t  |¡}||}t  |¡t  |¡}}|||}||d||}|r$|dk|||ffS|dkSdS)$av The old stopping function utilized by :class:`DynamicSampler`. Zipped parameters are passed to the function via :data:`args`. Assigns the run a stopping value based on a weighted average of the stopping values for the posterior and evidence:: stop = pfrac * stop_post + (1.- pfrac) * stop_evid The evidence stopping value is based on the estimated evidence error (i.e. standard deviation) relative to a given threshold:: stop_evid = evid_std / evid_thresh The posterior stopping value is based on the fractional error (i.e. standard deviation / mean) in the Kullback-Leibler (KL) divergence relative to a given threshold:: stop_post = (kld_std / kld_mean) / post_thresh Estimates of the mean and standard deviation are computed using `n_mc` realizations of the input using a provided `'error'` keyword (either `'jitter'` or `'resample'`). Returns the boolean `stop <= 1`. If `True`, the :class:`DynamicSampler` will stop adding new samples to our results. Parameters ---------- results : :class:`Results` instance :class:`Results` instance. args : dictionary of keyword arguments, optional Arguments used to set the stopping values. Default values are `pfrac = 1.0`, `evid_thresh = 0.1`, `post_thresh = 0.02`, `n_mc = 128`, `error = 'jitter'`, and `approx = True`. rstate : `~numpy.random.Generator`, optional `~numpy.random.Generator` instance. M : `map` function, optional An alias to a `map`-like function. This allows users to pass functions from pools (e.g., `pool.map`) to compute realizations in parallel. By default the standard `map` function is used. return_vals : bool, optional Whether to return the stopping value (and its components). Default is `False`. Returns ------- stop_flag : bool Boolean flag indicating whether we have passed the desired stopping criteria. stop_vals : tuple of shape (3,), optional The individual stopping values `(stop_post, stop_evid, stop)` used to determine the stopping criteria. ÚoncezEThis an old stopping function that will be removed in future releasesNÚpfracgð?gzThe provided `pfrac` z is not between 0. and 1.Ú evid_threshgš™™™™™¹?zThe provided `evid_thresh` z, is not non-negative even though `pfrac` is Ú.Ú post_threshg{®Gáz”?zThe provided `post_thresh` Ún_mcé€rzThe number of realizations z must be greater than 1.éz`Using a small number of realizations might result in excessively noisy stopping value estimates.r?r=>r=r>zThe chosen `'error'` option z is not valid.rTcsg|]}ˆ‘qSr'r')r@rü)r„r'r(rB©sz)old_stopping_function..csg|]}ˆ‘qSr'r')r@rü)r?r'r(rBªscsg|]}ˆ‘qSr'r')r@rü)rr'r(rB«scSs"g|]\}}|d|jdf‘qS)rˆ)r)r@rArÕr'r'r(rB¯s)r^Úcatch_warningsÚfilterwarningsr_ÚDeprecationWarningrDÚgetr·rrîr'rCrEr\r]ÚTZstdrõ)r„rDrÒÚMZ return_valsrGrHrJrKZrlistZ error_listZ approx_listríÚoutputsZkld_arrZlnz_arrZlnz_stdZ stop_evidZkld_meanZkld_stdZ stop_postÚstopr')rr?r„r(Úold_stopping_functionPs\2               rVc CsÒt|dƒ}t |¡}WdQRX|d}|d}d}|d}||krLtdƒ‚|tkrft d|›d ¡|dk rv|j}nt}t|dƒr¦||j g} |j dk r¬|   |j ¡n|g} x | D]} || _ || _ || j_ q²W|S) aö Restore the dynamic sampler from a file. It is assumed that the file was created using .save() method of DynamicNestedSampler or as a result of checkpointing during run_nested() Parameters ---------- fname: string Filename of the save file. pool: object(optional) The multiprocessing pool-like object that supports map() calls that will be used in the restored object. Returns ------- Static or dynamic nested sampling object ÚrbNÚsamplerÚversionrÚformat_versionzIncorrect format versionz,The dynesty version in the checkpoint file (z`)does not match the current dynesty version({DYNESTY_VERSION}). That is *NOT* guaranteed to work)ÚopenÚ pickle_moduleÚloadrSÚDYNESTY_VERSIONr^r_rDrŸrXZ batch_samplerrprSr7r6) Úfnamer7rXrÕrXZsave_verZdynesty_format_versionZfile_format_versionZmapperZsamplersZcursampr'r'r(Úrestore_samplerÃs0     r`c Cszd}|t|dœ}|d}y2t|dƒ}t ||¡WdQRXt ||¡Wn*yt |¡Wn YnX‚YnXdS)zË Save the state of the dynamic sampler in a file Parameters ---------- sampler: object Dynamic or Static nested sampler fname: string Filename of the save file. r)rXrYrZz.tmpÚwbN)r^r[r\ÚdumpÚosÚrenameÚunlink)rXr_rZrmZ tmp_fnamerXr'r'r(Ú save_samplerþs  rf)N)N)N)N)NF)NNN)NF)N)T)T)r=NFF)F)NNNF)N)Lr5rœr^rrbrtrcr Ú collectionsrÚ functoolsrÚpickler\Únumpyr\Z scipy.specialrÚ_versionrr^rãÚ ImportErrorrRÚ__all__rŠr*ZfinfoZfloat64Zepsrørr#Z _LOWL_VALrrrrrwr‰r‡rŽrƒr‚rØr®rÚrrÛrrârårÓrîrðrrór rr rr r rr$r r rrr7rr5rErVr`rfr'r'r'r(Ús            ?=" R;($ "   ' F /$, ^ ? ) 0 j V @ w o ;