B d3T@sddlmZyddlmZmZWn$ek rDedZedZYnXddlZddlZGddde Z Gdd d e Z Gd d d e Z Gd d d e Z Gddde ZGddde ZGdddeZGddde ZGddde ZdS)) bisect_right)PosInfNegInfz+infz-infNc@sHeZdZdZddZddZddZdd Zd d Zd d Z ddZ dS)Binsz Parent class for 1-dimensional binnings. Not intended to be used directly, but to be subclassed for use in real bins classes. cCsLt|tst||dkr"t|||kr6t||f||_||_||_dS)a  Initialize a Bins instance. The three arguments are the minimum and maximum of the values spanned by the bins, and the number of bins to place between them. Subclasses may require additional arguments, or different arguments altogether. N) isinstanceint TypeError ValueErrorminvmaxvn)selfr r r r\/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/pycbc/bin_utils.py__init__s  z Bins.__init__cCs|jS)N)r )rrrr__len__(sz Bins.__len__cCsft|tr^|jdk r$tdt|t|jdk r:||jnd|jdk rT||jdnt|StdS)a< Convert a co-ordinate to a bin index. The co-ordinate can be a single value, or a Python slice instance describing a range of values. If a single value is given, it is mapped to the bin index corresponding to that value. If a slice is given, it is converted to a slice whose lower bound is the index of the bin in which the slice's lower bound falls, and whose upper bound is 1 greater than the index of the bin in which the slice's upper bound falls. Steps are not supported in slices. Nzstep not supported: %srr)rslicestepNotImplementedErrorreprstartstoplen)rxrrr __getitem__+s   zBins.__getitem__cCstdS)z If __iter__ does not exist, Python uses __getitem__ with range(0) as input to define iteration. This is nonsensical for bin objects, so explicitly unsupport iteration. N)r)rrrr__iter__?sz Bins.__iter__cCstdS)zg Return an array containing the locations of the lower boundaries of the bins. N)r)rrrrlowerGsz Bins.lowercCstdS)zV Return an array containing the locations of the bin centres. N)r)rrrrcentresNsz Bins.centrescCstdS)zg Return an array containing the locations of the upper boundaries of the bins. N)r)rrrrupperUsz Bins.upperN) __name__ __module__ __qualname____doc__rrrrrrrrrrrr srcs@eZdZdZddZfddZddZdd Zd d ZZ S) IrregularBinsa@ Bins with arbitrary, irregular spacing. We only require strict monotonicity of the bin boundaries. N boundaries define N-1 bins. Example: >>> x = IrregularBins([0.0, 11.0, 15.0, numpy.inf]) >>> len(x) 3 >>> x[1] 0 >>> x[1.5] 0 >>> x[13] 1 >>> x[25] 2 >>> x[4:17] slice(0, 3, None) >>> IrregularBins([0.0, 15.0, 11.0]) Traceback (most recent call last): ... ValueError: non-monotonic boundaries provided >>> y = IrregularBins([0.0, 11.0, 15.0, numpy.inf]) >>> x == y True cCsxt|dkrtdt|}tddt|dd|ddDrLtd||_t|d|_|d |_|d|_dS) z Initialize a set of custom bins with the bin boundaries. This includes all left edges plus the right edge. The boundaries must be monotonic and there must be at least two elements. z!less than two boundaries providedcss|]\}}||kVqdS)Nr).0abrrr sz)IrregularBins.__init__..Nrz!non-monotonic boundaries providedr) rr tupleanyzip boundariesr r r )rr.rrrrzs ( zIrregularBins.__init__csjt|trtt||S|j|kr2|jkrFnnt|j|dS||jkr^t |jdSt |dS)Nrr%) rrsuperr$rr r rr.r IndexError)rr) __class__rrrs  zIrregularBins.__getitem__cCst|jddS)Nr*)numpyarrayr.)rrrrrszIrregularBins.lowercCst|jddS)Nr)r2r3r.)rrrrrszIrregularBins.uppercCs||dS)Ng@)rr)rrrrrszIrregularBins.centres) r r!r"r#rrrrr __classcell__rr)r1rr$]s  r$csDeZdZdZfddZfddZddZdd Zd d ZZ S) LinearBinsa Linearly-spaced bins. There are n bins of equal size, the first bin starts on the lower bound and the last bin ends on the upper bound inclusively. Example: >>> x = LinearBins(1.0, 25.0, 3) >>> x.lower() array([ 1., 9., 17.]) >>> x.upper() array([ 9., 17., 25.]) >>> x.centres() array([ 5., 13., 21.]) >>> x[1] 0 >>> x[1.5] 0 >>> x[10] 1 >>> x[25] 2 >>> x[0:27] Traceback (most recent call last): ... IndexError: 0 >>> x[1:25] slice(0, 3, None) >>> x[:25] slice(0, 3, None) >>> x[10:16.9] slice(1, 2, None) >>> x[10:17] slice(1, 3, None) >>> x[10:] slice(1, 3, None) cs*tt||||t||||_dS)N)r/r5rfloatdelta)rr r r )r1rrrszLinearBins.__init__csrt|trtt||S|j|kr2|jkrPnntt ||j|j S||jkrft |dSt |dS)Nr) rrr/r5rr r rmathfloorr7rr0)rr)r1rrrs   zLinearBins.__getitem__cCst|j|j|jt|S)N)r2linspacer r r7r)rrrrrszLinearBins.lowercCs*t|j|jd|j|jdt|S)Ng@)r2r:r r7r r)rrrrrszLinearBins.centrescCst|j|j|jt|S)N)r2r:r r7r r)rrrrrszLinearBins.upper) r r!r"r#rrrrrr4rr)r1rr5s &  r5csDeZdZdZfddZfddZddZdd Zd d ZZ S) LinearPlusOverflowBinsaY Linearly-spaced bins with overflow at the edges. There are n-2 bins of equal size. The bin 1 starts on the lower bound and bin n-2 ends on the upper bound. Bins 0 and n-1 are overflow going from -infinity to the lower bound and from the upper bound to +infinity respectively. Must have n >= 3. Example: >>> x = LinearPlusOverflowBins(1.0, 25.0, 5) >>> x.centres() array([-inf, 5., 13., 21., inf]) >>> x.lower() array([-inf, 1., 9., 17., 25.]) >>> x.upper() array([ 1., 9., 17., 25., inf]) >>> x[float("-inf")] 0 >>> x[0] 0 >>> x[1] 1 >>> x[10] 2 >>> x[24.99999999] 3 >>> x[25] 4 >>> x[100] 4 >>> x[float("+inf")] 4 >>> x[float("-inf"):9] slice(0, 3, None) >>> x[9:float("+inf")] slice(2, 5, None) cs>|dkrtdtt||||t|||d|_dS)Nzn must be >= 3r%)r r/r;rr6r7)rr r r )r1rrr szLinearPlusOverflowBins.__init__cst|trtt||S|j|kr2|jkrTnntt ||j|j dS||jkrjt |dS||jkrxdSt |dS)Nrr) rrr/r;rr r rr8r9r7rr0)rr)r1rrrs    z"LinearPlusOverflowBins.__getitem__c Cs<tttg|j|jtt|dt|jgfS)Nr%) r2 concatenater3rr r7arangerr )rrrrrs zLinearPlusOverflowBins.lowerc Cs>tttg|j|jtt|ddttgfS)Nr%g?) r2r=r3rr r7r>rr)rrrrr#s  zLinearPlusOverflowBins.centresc Cs@tt|jg|j|jtt|ddttgfS)Nr%r)r2r=r3r r7r>rr)rrrrr*s  zLinearPlusOverflowBins.upper) r r!r"r#rrrrrr4rr)r1rr;s '  r;csDeZdZdZfddZfddZddZdd Zd d ZZ S) LogarithmicBinsaX Logarithmically-spaced bins. There are n bins, each of whose upper and lower bounds differ by the same factor. The first bin starts on the lower bound, and the last bin ends on the upper bound inclusively. Example: >>> x = LogarithmicBins(1.0, 25.0, 3) >>> x[1] 0 >>> x[5] 1 >>> x[25] 2 cs2tt||||t|t|||_dS)N)r/r?rr8logr7)rr r r )r1rrrEszLogarithmicBins.__init__cs~t|trtt||S|j|kr2|jkr\nn&tt t |t |j|j S||jkrrt |dSt |dS)Nr)rrr/r?rr r rr8r9r@r7rr0)rr)r1rrrIs    zLogarithmicBins.__getitem__cCs.ttt|jt|j|jt|S)N) r2expr:r8r@r r r7r)rrrrrTszLogarithmicBins.lowercCs8ttt|jt|j|jt||jdS)Ng@) r2rAr:r8r@r r r7r)rrrrrZszLogarithmicBins.centrescCs.ttt|j|jt|jt|S)N) r2rAr:r8r@r r7r r)rrrrr`szLogarithmicBins.upper) r r!r"r#rrrrrr4rr)r1rr?2s   r?csDeZdZdZfddZfddZddZdd Zd d ZZ S) LogarithmicPlusOverflowBinsa Logarithmically-spaced bins plus one bin at each end that goes to zero and positive infinity respectively. There are n-2 bins each of whose upper and lower bounds differ by the same factor. Bin 1 starts on the lower bound, and bin n-2 ends on the upper bound inclusively. Bins 0 and n-1 are overflow bins extending from 0 to the lower bound and from the upper bound to +infinity respectively. Must have n >= 3. Example: >>> x = LogarithmicPlusOverflowBins(1.0, 25.0, 5) >>> x[0] 0 >>> x[1] 1 >>> x[5] 2 >>> x[24.999] 3 >>> x[25] 4 >>> x[100] 4 >>> x.lower() array([ 0. , 1. , 2.92401774, 8.54987973, 25. ]) >>> x.upper() array([ 1. , 2.92401774, 8.54987973, 25. , inf]) >>> x.centres() array([ 0. , 1.70997595, 5. , 14.62008869, inf]) csF|dkrtdtt||||t|t||d|_dS)Nr<zn must be >= 3r%)r r/rBrr8r@r7)rr r r )r1rrrsz$LogarithmicPlusOverflowBins.__init__cst|trtt||S|j|kr2|jkr`nn*dtt t |t |j|j S||jkrvt |dS||jkrdSt |dS)Nrr)rrr/rBrr r rr8r9r@r7rr0)rr)r1rrrs    z'LogarithmicPlusOverflowBins.__getitem__c Cs>ttdgttt|jt|jt |dfS)Ngr) r2r=r3rAr:r8r@r r r)rrrrrs z!LogarithmicPlusOverflowBins.lowerc CsXttdgttt|jt|j|j t |d|j dtt gfS)Ngr%g@) r2r=r3rAr:r8r@r r r7rr)rrrrrs  z#LogarithmicPlusOverflowBins.centresc Cs>tttt|jt|jt|dt t gfS)Nr) r2r=rAr:r8r@r r rr3r)rrrrrsz!LogarithmicPlusOverflowBins.upper) r r!r"r#rrrrrr4rr)r1rrBgs     rBc@s8eZdZdZddZddZddZdd Zd d Zd S) NDBinsa Multi-dimensional co-ordinate binning. An instance of this object is used to convert a tuple of co-ordinates into a tuple of bin indices. This can be used to allow the contents of an array object to be accessed with real-valued coordinates. NDBins is a subclass of the tuple builtin, and is initialized with an iterable of instances of subclasses of Bins. Each Bins subclass instance describes the binning to apply in the corresponding co-ordinate direction, and the number of them sets the dimensions of the binning. Example: >>> x = NDBins((LinearBins(1, 25, 3), LogarithmicBins(1, 25, 3))) >>> x[1, 1] (0, 0) >>> x[1.5, 1] (0, 0) >>> x[10, 1] (1, 0) >>> x[1, 5] (0, 1) >>> x[1, 1:5] (0, slice(0, 2, None)) >>> x.centres() (array([ 5., 13., 21.]), array([ 1.70997595, 5. , 14.62008869])) Note that the co-ordinates to be converted must be a tuple, even if it is only a 1-dimensional co-ordinate. cGsPtj|f|}tdd|D|_tdd|D|_tdd|D|_|S)Ncss|] }|jVqdS)N)r )r&r(rrrr)sz!NDBins.__new__..css|] }|jVqdS)N)r )r&r(rrrr)scss|]}t|VqdS)N)r)r&r(rrrr)s)r+__new__r r shape)clsargsnewrrrrDs zNDBins.__new__cCsFt|tr6t|t|kr"tdttdd||St||SdS)a When coords is a tuple, it is interpreted as an N-dimensional co-ordinate which is converted to an N-tuple of bin indices by the Bins instances in this object. Otherwise coords is interpeted as an index into the tuple, and the corresponding Bins instance is returned. Example: >>> x = NDBins((LinearBins(1, 25, 3), LogarithmicBins(1, 25, 3))) >>> x[1, 1] (0, 0) >>> type(x[1]) When used to convert co-ordinates to bin indices, each co-ordinate can be anything the corresponding Bins instance will accept. Note that the co-ordinates to be converted must be a tuple, even if it is only a 1-dimensional co-ordinate. zdimension mismatchcSs||S)Nr)r(crrrz$NDBins.__getitem__..N)rr+rr mapr)rcoordsrrrrs  zNDBins.__getitem__cCstdd|DS)z Return a tuple of arrays, where each array contains the locations of the lower boundaries of the bins in the corresponding dimension. css|]}|VqdS)N)r)r&r(rrrr)szNDBins.lower..)r+)rrrrrsz NDBins.lowercCstdd|DS)z Return a tuple of arrays, where each array contains the locations of the bin centres for the corresponding dimension. css|]}|VqdS)N)r)r&r(rrrr) sz!NDBins.centres..)r+)rrrrrszNDBins.centrescCstdd|DS)z Return a tuple of arrays, where each array contains the locations of the upper boundaries of the bins in the corresponding dimension. css|]}|VqdS)N)r)r&r(rrrr)szNDBins.upper..)r+)rrrrr sz NDBins.upperN) r r!r"r#rDrrrrrrrrrCs  rCc@s\eZdZdZdddZddZdd Zd d Zd d ZddZ ddZ ddZ dddZ dS) BinnedArraya A convenience wrapper, using the NDBins class to provide access to the elements of an array object. Technical reasons preclude providing a subclass of the array object, so the array data is made available as the "array" attribute of this class. Examples: Note that even for 1 dimensional arrays the index must be a tuple. >>> x = BinnedArray(NDBins((LinearBins(0, 10, 5),))) >>> x.array array([ 0., 0., 0., 0., 0.]) >>> x[0,] += 1 >>> x[0.5,] += 1 >>> x.array array([ 2., 0., 0., 0., 0.]) >>> x.argmax() (1.0,) Note the relationship between the binning limits, the bin centres, and the co-ordinates of the BinnedArray >>> x = BinnedArray(NDBins((LinearBins(-0.5, 1.5, 2), LinearBins(-0.5, 1.5, 2)))) >>> x.bins.centres() (array([ 0., 1.]), array([ 0., 1.])) >>> x[0, 0] = 0 >>> x[0, 1] = 1 >>> x[1, 0] = 2 >>> x[1, 1] = 4 >>> x.array array([[ 0., 1.], [ 2., 4.]]) >>> x[0, 0] 0.0 >>> x[0, 1] 1.0 >>> x[1, 0] 2.0 >>> x[1, 1] 4.0 >>> x.argmin() (0.0, 0.0) >>> x.argmax() (1.0, 1.0) NdoublecCs@||_|dkr"tj|j|d|_n|j|jkr6td||_dS)N)dtypez3input array and input bins must have the same shape)binsr2ZzerosrEr3r )rrQr3rPrrrrEs  zBinnedArray.__init__cCs|j|j|S)N)r3rQ)rrMrrrrOszBinnedArray.__getitem__cCs||j|j|<dS)N)r3rQ)rrMvalrrr __setitem__RszBinnedArray.__setitem__cCs t|jS)N)rr3)rrrrrUszBinnedArray.__len__cCst||j|jS)zm Return a copy of the BinnedArray. The .bins attribute is shared with the original. )typerQr3copy)rrrrrUXszBinnedArray.copycCs |jS)za Return a tuple of arrays containing the bin centres for each dimension. )rQr)rrrrr_szBinnedArray.centrescCs.tddt|t|j|jjDS)z Return the co-ordinates of the bin centre containing the minimum value. Same as numpy.argmin(), converting the indexes to bin co-ordinates. css|]\}}||VqdS)Nr)r&rindexrrrr)lsz%BinnedArray.argmin..)r+r-rr2 unravel_indexr3argminrE)rrrrrXfszBinnedArray.argmincCs.tddt|t|j|jjDS)z Return the co-ordinates of the bin centre containing the maximum value. Same as numpy.argmax(), converting the indexes to bin co-ordinates. css|]\}}||VqdS)Nr)r&rrVrrrr)vsz%BinnedArray.argmax..)r+r-rr2rWr3argmaxrE)rrrrrYpszBinnedArray.argmaxcCs||j|jdk<|S)z Find bins <= 0, and set them to epsilon, This has the effect of allowing the logarithm of the array to be evaluated without error. r)r3)repsilonrrr logregularizezszBinnedArray.logregularize)NrO)rZ) r r!r"r#rrrSrrUrrXrYr\rrrrrNs0   rNc@s`eZdZdZdddZddZddZdd d Zdd d ZddZ ddZ dddZ ddZ dS) BinnedRatiosa Like BinnedArray, but provides a numerator array and a denominator array. The incnumerator() method increments a bin in the numerator by the given weight, and the incdenominator() method increments a bin in the denominator by the given weight. There are no methods provided for setting or decrementing either, but the they are accessible as the numerator and denominator attributes, which are both BinnedArray objects. rOcCs t||d|_t||d|_dS)N)rP)rN numerator denominator)rrQrPrrrrszBinnedRatios.__init__cCs|j||j|S)N)r^r_)rrMrrrrszBinnedRatios.__getitem__cCs|jjS)N)r^rQ)rrrrrQszBinnedRatios.binsrcCs|j||7<dS)z< Add weight to the numerator bin at coords. N)r^)rrMweightrrr incnumeratorszBinnedRatios.incnumeratorcCs|j||7<dS)z> Add weight to the denominator bin at coords. N)r_)rrMr`rrrincdenominatorszBinnedRatios.incdenominatorcCs|jj|jjS)z9 Compute and return the array of ratios. )r^r3r_)rrrrratioszBinnedRatios.ratiocCsd|jj|jjdk<|S)aA Find bins in the denominator that are 0, and set them to 1. Presumably the corresponding bin in the numerator is also 0, so this has the effect of allowing the ratio array to be evaluated without error, returning zeros in those bins that have had no weight added to them. rr)r_r3)rrrr regularizeszBinnedRatios.regularizecCs,||jj|jjdk<d|jj|jjdk<|S)a  Find bins in the denominator that are 0, and set them to 1, while setting the corresponding bin in the numerator to float epsilon. This has the effect of allowing the logarithm of the ratio array to be evaluated without error. rr)r^r3r_)rr[rrrr\szBinnedRatios.logregularizecCs |jjS)za Return a tuple of arrays containing the bin centres for each dimension. )r^rQr)rrrrrszBinnedRatios.centresN)rO)r)r)re) r r!r"r#rrrQrarbrcrdr\rrrrrr]s     r])bisectrZfpconstrr ImportErrorr6r2r8objectrr$r5r;r?rBr+rCrNr]rrrrs QD@Q5O^p