B ú‹dÇžã @sÂdZddlmZddlZddlZddlmZddlmZm Z m Z ddl m Z dd d d d gZ ed ddddddddgƒZdd„Zdd „Zdd„Zd#dd„Zdd„Zdd„Zd d „Zd!d „Zd"d „ZdS)$zÀ Functions for proposing new live points used by :class:`~dynesty.sampler.Sampler` (and its children from :mod:`~dynesty.nestedsamplers`) and :class:`~dynesty.dynamicsampler.DynamicSampler`. é)Ú namedtupleN)Úlinalgé)Ú unitcheckÚ apply_reflectÚget_random_generator)Ú randsphereÚ sample_unifÚ sample_rwalkÚ sample_sliceÚ sample_rsliceÚ sample_hsliceÚSamplerArgumentÚuÚloglstarÚaxesÚscaleÚprior_transformÚ loglikelihoodÚrseedÚkwargscCs:| t |j¡¡}| t |¡¡}d}d}|j||||fS)aƒ Evaluate a new point sampled uniformly from a bounding proposal distribution. Parameters are zipped within `args` to utilize `pool.map`-style functions. Parameters ---------- u : `~numpy.ndarray` with shape (npdim,) Position of the initial sample. loglstar : float Ln(likelihood) bound. **Not applicable here.** axes : `~numpy.ndarray` with shape (ndim, ndim) Axes used to propose new points. **Not applicable here.** scale : float Value used to scale the provided axes. **Not applicable here.** prior_transform : function Function transforming a sample from the a unit cube to the parameter space of interest according to the prior. loglikelihood : function Function returning ln(likelihood) given parameters as a 1-d `~numpy` array of length `ndim`. kwargs : dict A dictionary of additional method-specific parameters. **Not applicable here.** Returns ------- u : `~numpy.ndarray` with shape (npdim,) Position of the final proposed point within the unit cube. **For uniform sampling this is the same as the initial input position.** v : `~numpy.ndarray` with shape (ndim,) Position of the final proposed point in the target parameter space. logl : float Ln(likelihood) of the final proposed point. nc : int Number of function calls used to generate the sample. For uniform sampling this is `1` by construction. blob : dict Collection of ancillary quantities used to tune :data:`scale`. **Not applicable for uniform sampling.** rN)rÚnpÚasarrayrr)ÚargsÚvÚloglÚncÚblob©rú]/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/dynesty/sampling.pyr s 9c Cs.t|jƒ}t|j|j|j|j|j|j||j ƒS)aÔ Return a new live point proposed by random walking away from an existing live point. Parameters ---------- u : `~numpy.ndarray` with shape (npdim,) Position of the initial sample. **This is a copy of an existing live point.** loglstar : float Ln(likelihood) bound. axes : `~numpy.ndarray` with shape (ndim, ndim) Axes used to propose new points. For random walks new positions are proposed using the :class:`~dynesty.bounding.Ellipsoid` whose shape is defined by axes. scale : float Value used to scale the provided axes. prior_transform : function Function transforming a sample from the a unit cube to the parameter space of interest according to the prior. loglikelihood : function Function returning ln(likelihood) given parameters as a 1-d `~numpy` array of length `ndim`. kwargs : dict A dictionary of additional method-specific parameters. Returns ------- u : `~numpy.ndarray` with shape (npdim,) Position of the final proposed point within the unit cube. v : `~numpy.ndarray` with shape (ndim,) Position of the final proposed point in the target parameter space. logl : float Ln(likelihood) of the final proposed point. nc : int Number of function calls used to generate the sample. blob : dict Collection of ancillary quantities used to tune :data:`scale`. ) rrÚgeneric_random_walkrrrrrrr)rÚrstaterrrr _s5 c Csú| d¡}| d¡} | d¡} t|ƒ} |jd} | dd¡} d}d}d}x~|| krÆt|||| | || | |d \}}|r†|d7}|d7}qJ||ƒ}||ƒ}|d7}||kr¼|}|}|}|d7}qJ|d7}qJW|dkrà||ƒ}||ƒ}|||d œ}|||||fS) a“ Generic random walk step Parameters ---------- u : `~numpy.ndarray` with shape (npdim,) Position of the initial sample. **This is a copy of an existing live point.** loglstar : float Ln(likelihood) bound. axes : `~numpy.ndarray` with shape (ndim, ndim) Axes used to propose new points. For random walks new positions are proposed using the :class:`~dynesty.bounding.Ellipsoid` whose shape is defined by axes. scale : float Value used to scale the provided axes. prior_transform : function Function transforming a sample from the a unit cube to the parameter space of interest according to the prior. loglikelihood : function Function returning ln(likelihood) given parameters as a 1-d `~numpy` array of length `ndim`. kwargs : dict A dictionary of additional method-specific parameters. Returns ------- u : `~numpy.ndarray` with shape (npdim,) Position of the final proposed point within the unit cube. v : `~numpy.ndarray` with shape (ndim,) Position of the final proposed point in the target parameter space. logl : float Ln(likelihood) of the final proposed point. nc : int Number of function calls used to generate the sample. blob : dict Collection of ancillary quantities used to tune :data:`scale`. Ú nonboundedÚperiodicÚ reflectiverÚwalksé)r!r#r$r"r)ÚacceptZrejectr)ÚgetÚlenÚshapeÚpropose_ball_point)rrrrrrr!rr"r#r$ÚnÚ n_clusterr%ZnacceptZnrejectÚncallÚu_propZfailÚv_propÚ logl_proprrrrrrr šsJ4          r c Csª|d|…} | ||¡} t |¡} | | |d…<t||d} t || ¡} | || | d|…<|dk rxt | |d¡| |<|dk rt| |ƒ| |<t| |ƒr¢| dfSdSdS)zç Here we are proposing points uniformly within an n-d ellipsoid. We are only trying once. We return the tuple with 1) proposed point or None 2) failure flag (if True, the generated point was outside bounds) N)r!rF)NT)ÚrandomrÚzerosrÚdotÚmodrr)rrrr,r-r!r#r$r"Z u_clusterZ u_non_clusterr/ZdrZdurrrr+s      r+c Cs¬||}}|} |} d} x||dkr¦||d} d| krD|ks^n|| krZdkrbnnd} || kr|| }||ƒd} n| }||ƒd} | r|| kr|| krdSqWdS)aä Acceptance test of slice sampling when doubling mode is used. This is an exact implementation of algorithm 6 of Neal 2003 here w=1 and x0=0 as we are working in the coordinate system of F(A) = f(x0+A*w) Arguments are 1) candidate location x1 2) wrapped logl function (see generic_slice_step) 3) threshold logl value 4) left edge of the full interval 5) right edge of the full interval 6) value at left edge 7) value at right edge Fgš™™™™™ñ?g@rTrr) Úx1ÚFrÚLÚRÚfLÚfRZlhatZrhatZf_lhatZf_rhatÚDÚMrrrÚ_slice_doubling_accept?s   . r>c!sfd\‰}} d} tˆƒ} | ¡} t ˆ¡} t | ¡d}| |krH| |}nd}ˆ|‰‡‡‡‡‡‡fdd„}| }d| }||ƒd}||ƒd}d}|sx(||krÂ|d8}||ƒd}|d7}qœWx(||krì|d7}||ƒd}|d7}qÆW|| kr”d}t d | ›d ¡n„d}xn||ks*||kr‚| ¡}|d krV|||8}||ƒd}n|||7}||ƒd}||7}|d 9}qW|}|}|}|}x¶||}|| ¡|}||ƒ\}}| d7} ||krì|rèt|||||||ƒrìPnZ|d krü|}nJ|d kr |}n:t dˆ›d|›d|›d|›d|›d|›d|›dˆ›dƒ‚q–Wˆ|ƒ} || |ˆ|| |fS)a Do a slice generic slice sampling step along a specified dimension Arguments u: ndarray (ndim sized) Starting point in unit cube coordinates It MUST satisfy the logl>loglstar criterion direction: ndarray (ndim sized) Step direction vector nonperiodic: ndarray(bool) mask for nonperiodic variables loglstar: float the critical value of logl, so that new logl must be >loglstar loglikelihood: function prior_transform: function rstate: random state )rrrièg@rcs<ˆ|ˆ}t|ˆƒr$ˆˆ|ƒƒ}ntj }ˆd7‰||fS)Nr)rrÚinf)ÚxZu_newr)Ú directionrrÚ nonperiodicrrrrr7‡s   zgeneric_slice_step..FFTz1The slice sample interval was expanded more than z timesgà?érzRSlice sampler has failed to find a valid point. Some useful output quantities: u: z nstep_left: z nstep_right: z nstep_hat: z u_prop: z loglstar: z logl_prop: z direction: Ú ) r)r2rÚnormrÚsqrtÚwarningsÚwarnr>Ú RuntimeError)!rrArBrrrÚdoublingr!ÚnexpandÚ ncontractZnexpand_thresholdr,Zrand0ZdirlenÚmaxlenZdirnormr7Znstep_lZnstep_rÚlogl_lÚlogl_rÚexpansion_warningÚKÚVr8r9r:r;Z nstep_hatZ nstep_propr/r1r0r)rArrrBrrrÚgeneric_slice_stepdsr                    @ rSc Cs@|j|j|j|j|j|j|jf\}}}}}}}t|jƒ}|  dd¡} |  dd¡} t |ƒ} |j d| ksjt ‚|  dd¡} d} d}d}||j }d}x”t| ƒD]ˆ}t | ¡}| |¡xn|D]f}||}t||| |||| |ƒ\}}}}}}}|}| |7} ||7}||7}|r¸| s¸d}d} t d ¡q¸WqšW|||d œ}|||| |fS) aF Return a new live point proposed by a series of random slices away from an existing live point. Standard "Gibs-like" implementation where a single multivariate "slice" is a combination of `ndim` univariate slices through each axis. Parameters ---------- u : `~numpy.ndarray` with shape (npdim,) Position of the initial sample. **This is a copy of an existing live point.** loglstar : float Ln(likelihood) bound. axes : `~numpy.ndarray` with shape (ndim, ndim) Axes used to propose new points. For slices new positions are proposed along the arthogonal basis defined by :data:`axes`. scale : float Value used to scale the provided axes. prior_transform : function Function transforming a sample from the a unit cube to the parameter space of interest according to the prior. loglikelihood : function Function returning ln(likelihood) given parameters as a 1-d `~numpy` array of length `ndim`. kwargs : dict A dictionary of additional method-specific parameters. Returns ------- u : `~numpy.ndarray` with shape (npdim,) Position of the final proposed point within the unit cube. v : `~numpy.ndarray` with shape (ndim,) Position of the final proposed point in the target parameter space. logl : float Ln(likelihood) of the final proposed point. nc : int Number of function calls used to generate the sample. blob : dict Collection of ancillary quantities used to tune :data:`scale`. rBNÚslice_doublingFrÚsliceséTzd}| ¡Pnt |¡} |#}$t t|$ƒ¡rbd }nd}nd }|! t |¡¡| dk r¸Pq¸Wt |ƒt |ƒdkrðt |!ƒdkrÆ|!| t |!ƒ¡}!n t |¡}!| t |!¡¡| t | ¡¡|røP| |$}}#| dkrút | ¡}%xàt | ƒD]Ô}&t |¡t |¡}'}(|(|&d7<t|(| ƒrv|t |(¡ƒ})|t |)¡ƒj}*n tj }*d}|d7}|'|&d8<t|'| ƒrÆ|t |'¡ƒ}+|t |+¡ƒj},n tj },d}|rÚP|d7}|*|,d|%|&<q Wnè| |"ƒ}%|rÚg}-x¶t | ƒD]ª}&t |¡t |¡}'}(|(|&d7<t|(| ƒr\|t |(¡ƒ})nd}t |"¡})|'|&d8<t|'| ƒr–|t |'¡ƒ}+nd}t |"¡})|r¬P|- |)|+d¡qWt |-¡}-t |-|%¡}%|d7}|d|%t ||%¡t |%¡d}.t |.|¡}/|/t |.¡t |¡}/|/dkr>d}Pn|.}d} d}|d7}q’Wd\}}t |¡ }t |¡}d}xÆ|| k rB| t |¡¡dg} }!xÖ|| d|d|¡|7}t|| ƒr|t |¡ƒ}0|t |0¡ƒ}1|d7}|d7}|d7}ntj }1|1|krT|r*d}| ¡Pnt |¡} |1}$t t|$ƒ¡rNd }nd}nd }|! t |¡¡| dk r¤Pq¤Wt |ƒt |ƒdkrÜt |!ƒdkr²|!| t |!ƒ¡}!n t |¡}!| t |!¡¡| t | ¡¡|räP| |$}}1| dkræt | ¡}%xàt | ƒD]Ô}&t |¡t |¡}2}3|3|&d7<t|3| ƒrb|t |3¡ƒ}4|t |4¡ƒj}5n tj }5d}|d7}|2|&d8<t|2| ƒr²|t |2¡ƒ}6|t |6¡ƒj}7n tj }7d}|rÆP|d7}|5|7d|%|&<q Wnè| |0ƒ}%|rÆg}-x¶t | ƒD]ª}&t |¡t |¡}2}3|3|&d7<t|3| ƒrH|t |3¡ƒ}4nd}t |0¡}4|2|&d8<t|2| ƒr‚|t |2¡ƒ}6nd}t |0¡}4|r˜P|- |4|6d¡qWt |-¡}-t |-|%¡}%|d7}|d|%t ||%¡t |%¡d}.t |.|¡}/|/t |.¡t |¡}/|/dk r*d}Pn|.}d} d}|d7}q~Wt |ƒdk rp| d¡| d¡| d¡t |¡t |¡t |¡}}}t |ƒ}8tj|8td}9x2t t!||ƒƒD] \}&\}:};t |;|:¡|9|&< q¸Wt |9¡}<xrt "|9d|<k¡ r t#d|›d|›d|›d|›d ƒ‚|9t $|9¡}=|j|8|=d}>||>||>||>}}?}||}@| %¡}A||A|@}Bt|B| ƒ rž|t |B¡ƒ}C|t |C¡ƒ}Dntj }D|d7}|d7}|D|k rÈ|B}PnŽt |B|?|@¡}E|Edk r|B||><|9|>d|A9<nV|Edk r$|B||><|9|>|A9<n2t#d|›d|›d|›d|@›d |B›d|›d!|D›ƒ‚ qêWq²W|||d"œ}F|B|C|D||FfS)#aÕ Return a new live point proposed by "Hamiltonian" Slice Sampling using a series of random trajectories away from an existing live point. Each trajectory is based on the provided axes and samples are determined by moving forwards/backwards in time until the trajectory hits an edge and approximately reflecting off the boundaries. Once a series of reflections has been established, we propose a new live point by slice sampling across the entire path. Parameters ---------- u : `~numpy.ndarray` with shape (npdim,) Position of the initial sample. **This is a copy of an existing live point.** loglstar : float Ln(likelihood) bound. axes : `~numpy.ndarray` with shape (ndim, ndim) Axes used to propose new slice directions. scale : float Value used to scale the provided axes. prior_transform : function Function transforming a sample from the a unit cube to the parameter space of interest according to the prior. loglikelihood : function Function returning ln(likelihood) given parameters as a 1-d `~numpy` array of length `ndim`. kwargs : dict A dictionary of additional method-specific parameters. Returns ------- u : `~numpy.ndarray` with shape (npdim,) Position of the final proposed point within the unit cube. v : `~numpy.ndarray` with shape (ndim,) Position of the final proposed point in the target parameter space. logl : float Ln(likelihood) of the final proposed point. nc : int Number of function calls used to generate the sample. blob : dict Collection of ancillary quantities used to tune :data:`scale`. rBNrrUrVÚgradÚmax_moveédÚ compute_jacFgÐ?)rbg{®Gáz„?gð?)FFrTg»½×Ùß|Û=g»½×Ùß|ë=rCg®Gáz®ï¿)Zdtypegñh㈵øä>zRHamiltonian slice sampling appears to be stuck! Some useful output quantities: u: z u_left: z u_right: z loglstar: Ú.)ÚpzRSlice sampler has failed to find a valid point. Some useful output quantities: u: z u_hat: z u_prop: z logl_prop: )ÚnmoveÚnreflectrL)&rrrrrrrrrr(r)r*rXrZrcrrErr4ÚarrayÚcopyÚuniformÚappendrrr?ÚpopÚisfiniteÚfloatÚchoicer3ÚvalÚ enumerateÚzipÚanyrIÚsumr2)Grrrrrrrrr!rBr,rUrerfrhÚjitterrrkrlrLr\Znodes_lZnodes_mZnodes_rrdr^ZvelZu_lZu_rÚreverseZreflectr.Zu_outZu_inZv_rrOZlogl_outÚhÚiZu_r_lZu_r_rZv_r_rZlogl_r_rZv_r_lZlogl_r_lZjacZvel_refZdotprodZv_lrNZu_l_lZu_l_rZv_l_rZlogl_l_rZv_l_lZlogl_l_lZNchordsZaxlenÚnlÚnrZ axlen_initZaxprobr]Zu_mZu_hatZrpropr/r0r1Úsrrrrr ¸sö9                           &                      &      "     : )NNNN)Ú__doc__Ú collectionsrrGÚnumpyrrÚutilsrrrZboundingrÚ__all__rr r r r+r>rSr r r rrrrÚ s0     A;y )%mg