`i dZddlZddlZddlmZddlmZddlmZdZ ej ej ej gZ ejejejejgZejejejejgZe ezZeezZdeDZdeDZejdejd ejd ejd ej d ej!d iZ"dZ#ej$e#ddeDdeDzdeDzZ%dZ&ej$e&ddeDdeDzZ'dZ(dZ)dZ*dZ+dZ,dZ-dZ.dZ/dZ0ej1d Z2d.d"Z3 d/d#Z4d0d$Z5d1d&Z6 d2d'Z7d(Z8d3d*Z9d3d+Z:d3d,Z;d3d-Z  HHH Oc,g|]}t|Sr.0ts r r7s . . .1mA . . .rc,g|]}t|Srrrs r rr8s ====##===ra' #include #include #include template __global__ void local_maxima_1d( const int n, const T* __restrict__ x, long long* midpoints, long long* left_edges, long long* right_edges) { const int orig_idx = blockDim.x * blockIdx.x + threadIdx.x; const int idx = orig_idx + 1; if(idx >= n - 1) { return; } long long midpoint = -1; long long left = -1; long long right = -1; if(x[idx - 1] < x[idx]) { int i_ahead = idx + 1; while(i_ahead < n - 1 && x[i_ahead] == x[idx]) { i_ahead++; } if(x[i_ahead] < x[idx]) { left = idx; right = i_ahead - 1; midpoint = (left + right) / 2; } } midpoints[orig_idx] = midpoint; left_edges[orig_idx] = left; right_edges[orig_idx] = right; } template __global__ void peak_prominences( const int n, const int n_peaks, const T* __restrict__ x, const long long* __restrict__ peaks, const long long wlen, T* prominences, long long* left_bases, long long* right_bases) { const int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx >= n_peaks) { return; } const long long peak = peaks[idx]; long long i_min = 0; long long i_max = n - 1; if(wlen >= 2) { i_min = max(peak - wlen / 2, i_min); i_max = min(peak + wlen / 2, i_max); } left_bases[idx] = peak; long long i = peak; T left_min = x[peak]; while(i_min <= i && x[i] <= x[peak]) { if(x[i] < left_min) { left_min = x[i]; left_bases[idx] = i; } i--; } right_bases[idx] = peak; i = peak; T right_min = x[peak]; while(i <= i_max && x[i] <= x[peak]) { if(x[i] < right_min) { right_min = x[i]; right_bases[idx] = i; } i++; } prominences[idx] = x[peak] - max(left_min, right_min); } template<> __global__ void peak_prominences( const int n, const int n_peaks, const half* __restrict__ x, const long long* __restrict__ peaks, const long long wlen, half* prominences, long long* left_bases, long long* right_bases) { const int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx >= n_peaks) { return; } const long long peak = peaks[idx]; long long i_min = 0; long long i_max = n - 1; if(wlen >= 2) { i_min = max(peak - wlen / 2, i_min); i_max = min(peak + wlen / 2, i_max); } left_bases[idx] = peak; long long i = peak; half left_min = x[peak]; while(i_min <= i && x[i] <= x[peak]) { if(x[i] < left_min) { left_min = x[i]; left_bases[idx] = i; } i--; } right_bases[idx] = peak; i = peak; half right_min = x[peak]; while(i <= i_max && x[i] <= x[peak]) { if(x[i] < right_min) { right_min = x[i]; right_bases[idx] = i; } i++; } prominences[idx] = x[peak] - __hmax(left_min, right_min); } template __global__ void peak_widths( const int n, const T* __restrict__ x, const long long* __restrict__ peaks, const double rel_height, const T* __restrict__ prominences, const long long* __restrict__ left_bases, const long long* __restrict__ right_bases, double* widths, double* width_heights, double* left_ips, double* right_ips) { const int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx >= n) { return; } long long i_min = left_bases[idx]; long long i_max = right_bases[idx]; long long peak = peaks[idx]; double height = x[peak] - prominences[idx] * rel_height; width_heights[idx] = height; // Find intersection point on left side long long i = peak; while (i_min < i && height < x[i]) { i--; } double left_ip = (double) i; if(x[i] < height) { // Interpolate if true intersection height is between samples left_ip += (height - x[i]) / (x[i + 1] - x[i]); } // Find intersection point on right side i = peak; while(i < i_max && height < x[i]) { i++; } double right_ip = (double) i; if(x[i] < height) { // Interpolate if true intersection height is between samples right_ip -= (height - x[i]) / (x[i - 1] - x[i]); } widths[idx] = right_ip - left_ip; left_ips[idx] = left_ip; right_ips[idx] = right_ip; } template<> __global__ void peak_widths( const int n, const half* __restrict__ x, const long long* __restrict__ peaks, const double rel_height, const half* __restrict__ prominences, const long long* __restrict__ left_bases, const long long* __restrict__ right_bases, double* widths, double* width_heights, double* left_ips, double* right_ips) { const int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx >= n) { return; } long long i_min = left_bases[idx]; long long i_max = right_bases[idx]; long long peak = peaks[idx]; double height = ((double) x[peak]) - ((double) prominences[idx]) * rel_height; width_heights[idx] = height; // Find intersection point on left side long long i = peak; while (i_min < i && height < ((double) x[i])) { i--; } double left_ip = (double) i; if(((double) x[i]) < height) { // Interpolate if true intersection height is between samples left_ip += (height - ((double) x[i])) / ((double) (x[i + 1] - x[i])); } // Find intersection point on right side i = peak; while(i < i_max && height < ((double) x[i])) { i++; } double right_ip = (double) i; if(((double) x[i]) < height) { // Interpolate if true intersection height is between samples right_ip -= (height - ((double) x[i])) / ((double) (x[i - 1] - x[i])); } widths[idx] = right_ip - left_ip; left_ips[idx] = left_ip; right_ips[idx] = right_ip; } )z -std=c++11cg|]}d|d S)zlocal_maxima_1d<>rrxs r rr4s$BBB!----BBBrcg|]}d|d S)zpeak_prominences #include #include template __device__ __forceinline__ bool less( const T &a, const T &b ) { return ( a < b ); } template __device__ __forceinline__ bool greater( const T &a, const T &b ) { return ( a > b ); } template __device__ __forceinline__ bool less_equal( const T &a, const T &b ) { return ( a <= b ); } template __device__ __forceinline__ bool greater_equal( const T &a, const T &b ) { return ( a >= b ); } template __device__ __forceinline__ bool equal( const T &a, const T &b ) { return ( a == b ); } template __device__ __forceinline__ bool not_equal( const T &a, const T &b ) { return ( a != b ); } __device__ __forceinline__ void clip_plus( const bool &clip, const int &n, int &plus ) { if ( clip ) { if ( plus >= n ) { plus = n - 1; } } else { if ( plus >= n ) { plus -= n; } } } __device__ __forceinline__ void clip_minus( const bool &clip, const int &n, int &minus ) { if ( clip ) { if ( minus < 0 ) { minus = 0; } } else { if ( minus < 0 ) { minus += n; } } } template __device__ bool compare(const int comp, const T &a, const T &b) { if(comp == 0) { return less(a, b); } else if(comp == 1) { return greater(a, b); } else if(comp == 2) { return less_equal(a, b); } else if(comp == 3) { return greater_equal(a, b); } else if(comp == 4) { return equal(a, b); } else { return not_equal(a, b); } } template __global__ void boolrelextrema_1D( const int n, const int order, const bool clip, const int comp, const T *__restrict__ inp, bool *__restrict__ results) { const int tx { static_cast( blockIdx.x * blockDim.x + threadIdx.x ) }; const int stride { static_cast( blockDim.x * gridDim.x ) }; for ( int tid = tx; tid < n; tid += stride ) { const T data { inp[tid] }; bool temp { true }; for ( int o = 1; o < ( order + 1 ); o++ ) { int plus { tid + o }; int minus { tid - o }; clip_plus( clip, n, plus ); clip_minus( clip, n, minus ); temp &= compare( comp, data, inp[plus] ); temp &= compare( comp, data, inp[minus] ); } results[tid] = temp; } } template __global__ void boolrelextrema_2D( const int in_x, const int in_y, const int order, const bool clip, const int comp, const int axis, const T *__restrict__ inp, bool *__restrict__ results) { const int ty { static_cast( blockIdx.x * blockDim.x + threadIdx.x ) }; const int tx { static_cast( blockIdx.y * blockDim.y + threadIdx.y ) }; if ( ( tx < in_y ) && ( ty < in_x ) ) { int tid { tx * in_x + ty }; const T data { inp[tid] }; bool temp { true }; for ( int o = 1; o < ( order + 1 ); o++ ) { int plus {}; int minus {}; if ( axis == 0 ) { plus = tx + o; minus = tx - o; clip_plus( clip, in_y, plus ); clip_minus( clip, in_y, minus ); plus = plus * in_x + ty; minus = minus * in_x + ty; } else { plus = ty + o; minus = ty - o; clip_plus( clip, in_x, plus ); clip_minus( clip, in_x, minus ); plus = tx * in_x + plus; minus = tx * in_x + minus; } temp &= compare( comp, data, inp[plus] ); temp &= compare( comp, data, inp[minus] ); } results[tid] = temp; } } cg|]}d|d S)zboolrelextrema_1D.s"EEE=++EEErz, 2r * * ! # 7a<<  E1ffqE!H,y88DG FA1ffqE!H,y88 E*nnqE!H!4y!@!@DG FA*nnqE!H!4y!@!@ Krcftj|d}|jdkrtd|S)zEnsure argument `x` is a 1-D C-contiguous array. Returns ------- value : ndarray A 1-D C-contiguous array. C)orderrz`x` must be a 1-D array)r;asarrayndimrJvalues r _arg_x_as_expectedr}s7 Lc * * *E zQ2333 Lrc|d}nld|krDtj|tjdstj|}t |}n"t d||S)zEnsure argument `wlen` is of type `np.intp` and larger than 1. Used in `peak_prominences` and `peak_widths`. Returns ------- value : np.intp The original `value` rounded up to an integer or -1 if `value` was None. Nrhrsafez$`wlen` must be larger than 1, was {})r;can_castr=mathriintrJformatr{s r _arg_wlen_as_expectedrst } U}UDJ77 %Ie$$EE ? &--)) ) LrcDtj|}|jdkr tjgtj} |tjdd}n"#t $r}t d|d}~wwxYw|jdkrtd |S) a3Ensure argument `peaks` is a 1-D C-contiguous array of dtype('int64'). Used in `peak_prominences` and `peak_widths` to make `peaks` compatible with the signature of the wrapped Cython functions. Returns ------- value : ndarray A 1-D C-contiguous array with dtype('int64'). rr8rwF)rxcopyz+cannot safely cast `peaks` to dtype('intp')Nrz`peaks` must be a 1-D array) r;ryrMarrayr=astyperIrzrJ)r|es r _arg_peaks_as_expectedrs L  E zQ 2TZ000N TZs ?? NNNEFFAMN zQ6777 Ls"A$$ B.A>>Bctjjtjjztjjz}||}||}||}d|ko||ko ||ko||k} | ||<dS)Nr)rblockIdxr blockDim threadIdx) nrO left_bases right_basesouttidi_mini_maxpeakvalids r _check_prominence_invalidrsl ,.3<> )CMO ;C sOE  E :D J H5D= HTU] HuqyEyCHHHrFc D|rLtjtj|dk||jddz krt dtj|jd|j}tj|jdtj}tj|jdtj}|jd}d}||zdz |z} ttd|} | | f|f|jd|||||||f|||fS)Nrrzpeaks are not a valid indexr8r7peak_prominences) r;any logical_orr:rJr<r r=r5r>) r rOwlencheck prominencesrrrr@rApeak_prom_kernels r _peak_prominencesrs 8$/%!)UQWQZ!^5KLLMM86777*U[^17;;;KEKN$*===J*U[^4:>>>K AAHH q X-H' 6H!LL  h[ Q5$ ZMOOO  K //rc|dkrtd|td|td|td|jd|jdcxkr#|jdcxkr|jdksntd|jd}d}||zdz |z} |rl|dkrftj|tj } t | f|f|jd|||| ftj| rtd tj|jdtj } tj|jdtj } tj|jdtj } tj|jdtj }ttd |}|| f|f|||||||| | | |f | | | |fS) Nrz,`rel_height` must be greater or equal to 0.0zprominences must not be Nonezleft_bases must not be Nonezright_bases must not be Nonez?arrays in `prominence_data` must have the same shape as `peaks`r7rr8zprominence data is invalid peak_widths) rJrIr:r;zerosrjrrr<float64r5r>)r rO rel_heightrrrrrr@rAinvalidwidths width_heightsleft_ips right_ipspeak_widths_kernels r _peak_widthsrsBA~~GHHH677756666777 KNk/2 $ $ $ $j6Fq6I $ $ $ $ # $ $ $ $,-- -  AAHH q X-H ;Q*Qdj111! K( WQZ K A C C C 8G   ;9:: : Z Adl ; ; ;FJu{1~T\BBBMz%+a. ===H 5;q>>>>I), qII  h[ Auj+z; ) 5666 =(I 55rct|}t|}t|}t|||dS)a Calculate the prominence of each peak in a signal. The prominence of a peak measures how much a peak stands out from the surrounding baseline of the signal and is defined as the vertical distance between the peak and its lowest contour line. Parameters ---------- x : sequence A signal with peaks. peaks : sequence Indices of peaks in `x`. wlen : int, optional A window length in samples that optionally limits the evaluated area for each peak to a subset of `x`. The peak is always placed in the middle of the window therefore the given length is rounded up to the next odd integer. This parameter can speed up the calculation (see Notes). Returns ------- prominences : ndarray The calculated prominences for each peak in `peaks`. left_bases, right_bases : ndarray The peaks' bases as indices in `x` to the left and right of each peak. The higher base of each pair is a peak's lowest contour line. Raises ------ ValueError If a value in `peaks` is an invalid index for `x`. Warns ----- PeakPropertyWarning For indices in `peaks` that don't point to valid local maxima in `x`, the returned prominence will be 0 and this warning is raised. This also happens if `wlen` is smaller than the plateau size of a peak. Warnings -------- This function may return unexpected results for data containing NaNs. To avoid this, NaNs should either be removed or replaced. See Also -------- find_peaks Find peaks inside a signal based on peak properties. peak_widths Calculate the width of peaks. Notes ----- Strategy to compute a peak's prominence: 1. Extend a horizontal line from the current peak to the left and right until the line either reaches the window border (see `wlen`) or intersects the signal again at the slope of a higher peak. An intersection with a peak of the same height is ignored. 2. On each side find the minimal signal value within the interval defined above. These points are the peak's bases. 3. The higher one of the two bases marks the peak's lowest contour line. The prominence can then be calculated as the vertical difference between the peaks height itself and its lowest contour line. Searching for the peak's bases can be slow for large `x` with periodic behavior because large chunks or even the full signal need to be evaluated for the first algorithmic step. This evaluation area can be limited with the parameter `wlen` which restricts the algorithm to a window around the current peak and can shorten the calculation time if the window length is short in relation to `x`. However, this may stop the algorithm from finding the true global contour line if the peak's true bases are outside this window. Instead, a higher contour line is found within the restricted window leading to a smaller calculated prominence. In practice, this is only relevant for the highest set of peaks in `x`. This behavior may even be used intentionally to calculate "local" prominences. Tr)r}rrr)r rOrs r rr@sCb 1A "5 ) )E  & &D Qt4 8 8 88r?ct|}t|}|"t|}t|||d}t |||g|RddiS)a Calculate the width of each peak in a signal. This function calculates the width of a peak in samples at a relative distance to the peak's height and prominence. Parameters ---------- x : sequence A signal with peaks. peaks : sequence Indices of peaks in `x`. rel_height : float, optional Chooses the relative height at which the peak width is measured as a percentage of its prominence. 1.0 calculates the width of the peak at its lowest contour line while 0.5 evaluates at half the prominence height. Must be at least 0. See notes for further explanation. prominence_data : tuple, optional A tuple of three arrays matching the output of `peak_prominences` when called with the same arguments `x` and `peaks`. This data are calculated internally if not provided. wlen : int, optional A window length in samples passed to `peak_prominences` as an optional argument for internal calculation of `prominence_data`. This argument is ignored if `prominence_data` is given. Returns ------- widths : ndarray The widths for each peak in samples. width_heights : ndarray The height of the contour lines at which the `widths` where evaluated. left_ips, right_ips : ndarray Interpolated positions of left and right intersection points of a horizontal line at the respective evaluation height. Raises ------ ValueError If `prominence_data` is supplied but doesn't satisfy the condition ``0 <= left_base <= peak <= right_base < x.shape[0]`` for each peak, has the wrong dtype, is not C-contiguous or does not have the same shape. Warns ----- PeakPropertyWarning Raised if any calculated width is 0. This may stem from the supplied `prominence_data` or if `rel_height` is set to 0. Warnings -------- This function may return unexpected results for data containing NaNs. To avoid this, NaNs should either be removed or replaced. See Also -------- find_peaks Find peaks inside a signal based on peak properties. peak_prominences Calculate the prominence of peaks. Notes ----- The basic algorithm to calculate a peak's width is as follows: * Calculate the evaluation height :math:`h_{eval}` with the formula :math:`h_{eval} = h_{Peak} - P \cdot R`, where :math:`h_{Peak}` is the height of the peak itself, :math:`P` is the peak's prominence and :math:`R` a positive ratio specified with the argument `rel_height`. * Draw a horizontal line at the evaluation height to both sides, starting at the peak's current vertical position until the lines either intersect a slope, the signal border or cross the vertical position of the peak's base (see `peak_prominences` for an definition). For the first case, intersection with the signal, the true intersection point is estimated with linear interpolation. * Calculate the width as the horizontal distance between the chosen endpoints on both sides. As a consequence of this the maximal possible width for each peak is the horizontal distance between its bases. As shown above to calculate a peak's width its prominence and bases must be known. You can supply these yourself with the argument `prominence_data`. Otherwise, they are internally calculated (see `peak_prominences`). NTrr)r}rrrr)r rOrprominence_datars r rrsjj 1A "5 ) )E$T**+Aud$GGG 5* K K K Kd K KKrc t|}||dkrtdt|\} } } i} |d| | z dz} t||| \}}t | ||| } | | d<| | d<| | d<fd| D} |Z|| }t||| \}}t |||| } || d<fd | D} |\t||| \}}t || ||\}}| } || d <|| d <fd | D} |?t| || || } fd | D} ||Dt|}| tgdt|| ||St||| \}}t | d||| } fd| D} || tgdt|| || d| d| dt||| \}}t | d||| } fd| D} | | fS)a0 Find peaks inside a signal based on peak properties. This function takes a 1-D array and finds all local maxima by simple comparison of neighboring values. Optionally, a subset of these peaks can be selected by specifying conditions for a peak's properties. Parameters ---------- x : sequence A signal with peaks. height : number or ndarray or sequence, optional Required height of peaks. Either a number, ``None``, an array matching `x` or a 2-element sequence of the former. The first element is always interpreted as the minimal and the second, if supplied, as the maximal required height. threshold : number or ndarray or sequence, optional Required threshold of peaks, the vertical distance to its neighboring samples. Either a number, ``None``, an array matching `x` or a 2-element sequence of the former. The first element is always interpreted as the minimal and the second, if supplied, as the maximal required threshold. distance : number, optional Required minimal horizontal distance (>= 1) in samples between neighbouring peaks. Smaller peaks are removed first until the condition is fulfilled for all remaining peaks. prominence : number or ndarray or sequence, optional Required prominence of peaks. Either a number, ``None``, an array matching `x` or a 2-element sequence of the former. The first element is always interpreted as the minimal and the second, if supplied, as the maximal required prominence. width : number or ndarray or sequence, optional Required width of peaks in samples. Either a number, ``None``, an array matching `x` or a 2-element sequence of the former. The first element is always interpreted as the minimal and the second, if supplied, as the maximal required width. wlen : int, optional Used for calculation of the peaks prominences, thus it is only used if one of the arguments `prominence` or `width` is given. See argument `wlen` in `peak_prominences` for a full description of its effects. rel_height : float, optional Used for calculation of the peaks width, thus it is only used if `width` is given. See argument `rel_height` in `peak_widths` for a full description of its effects. plateau_size : number or ndarray or sequence, optional Required size of the flat top of peaks in samples. Either a number, ``None``, an array matching `x` or a 2-element sequence of the former. The first element is always interpreted as the minimal and the second, if supplied as the maximal required plateau size. .. versionadded:: 1.2.0 Returns ------- peaks : ndarray Indices of peaks in `x` that satisfy all given conditions. properties : dict A dictionary containing properties of the returned peaks which were calculated as intermediate results during evaluation of the specified conditions: * 'peak_heights' If `height` is given, the height of each peak in `x`. * 'left_thresholds', 'right_thresholds' If `threshold` is given, these keys contain a peaks vertical distance to its neighbouring samples. * 'prominences', 'right_bases', 'left_bases' If `prominence` is given, these keys are accessible. See `peak_prominences` for a description of their content. * 'width_heights', 'left_ips', 'right_ips' If `width` is given, these keys are accessible. See `peak_widths` for a description of their content. * 'plateau_sizes', left_edges', 'right_edges' If `plateau_size` is given, these keys are accessible and contain the indices of a peak's edges (edges are still part of the plateau) and the calculated plateau sizes. To calculate and return properties without excluding peaks, provide the open interval ``(None, None)`` as a value to the appropriate argument (excluding `distance`). Warns ----- PeakPropertyWarning Raised if a peak's properties have unexpected values (see `peak_prominences` and `peak_widths`). Warnings -------- This function may return unexpected results for data containing NaNs. To avoid this, NaNs should either be removed or replaced. See Also -------- find_peaks_cwt Find peaks using the wavelet transformation. peak_prominences Directly calculate the prominence of peaks. peak_widths Directly calculate the width of peaks. Notes ----- In the context of this function, a peak or local maximum is defined as any sample whose two direct neighbours have a smaller amplitude. For flat peaks (more than one sample of equal amplitude wide) the index of the middle sample is returned (rounded down in case the number of samples is even). For noisy signals the peak locations can be off because the noise might change the position of local maxima. In those cases consider smoothing the signal before searching for peaks or use other peak finding and fitting methods (like `find_peaks_cwt`). Some additional comments on specifying conditions: * Almost all conditions (excluding `distance`) can be given as half-open or closed intervals, e.g., ``1`` or ``(1, None)`` defines the half-open interval :math:`[1, \infty]` while ``(None, 1)`` defines the interval :math:`[-\infty, 1]`. The open interval ``(None, None)`` can be specified as well, which returns the matching properties without exclusion of peaks. * The border is always included in the interval used to select valid peaks. * For several conditions the interval borders can be specified with arrays matching `x` in shape which enables dynamic constrains based on the sample position. * The conditions are evaluated in the following order: `plateau_size`, `height`, `threshold`, `distance`, `prominence`, `width`. In most cases this order is the fastest one because faster operations are applied first to reduce the number of peaks that need to be evaluated later. * While indices in `peaks` are guaranteed to be at least `distance` samples apart, edges of flat peaks may be closer than the allowed `distance`. * Use `wlen` to reduce the time it takes to evaluate the conditions for `prominence` or `width` if `x` is large or has many local maxima (see `peak_prominences`). Nrz(`distance` must be greater or equal to 1 plateau_sizesrCrDc(i|]\}}||SrrrkeyrrYs r zfind_peaks..#LLL:3c5;LLLr peak_heightsc(i|]\}}||Srrrs r rzfind_peaks..rrleft_thresholdsright_thresholdsc(i|]\}}||Srrrs r rzfind_peaks..rrc(i|]\}}||Srrrs r rzfind_peaks..rr)rrr)rrc(i|]\}}||Srrrs r rzfind_peaks..rr)rrrrrrrc(i|]\}}||Srrrs r rzfind_peaks..rr) r}rJrGrRrZitemsrfrurupdateziprr)r height thresholdrn prominencewidthrr plateau_sizerOrCrD propertiesrrWrXrhminhmaxrarbrrwminwmaxrYs @r find_peaksrsR 1A1 CDDD%5a%8%8"E:{J#j014 +L!UCC d"=$==d &3 ?##- < $/ =!LLLL9I9I9K9KLLL  x +FAu== d"<t<<d %1 >"LLLL9I9I9K9KLLL +Iq%@@ d2K udD3"3"/o/d (7 $%)9 %&LLLL9I9I9K9KLLL 'qxBBd LLLL9I9I9K9KLLL !2$T**# 8 8 8 aT 2 2 2     +J5AA d":m#D   ""I&'<=BDJH 4 %tT7BI%K y1}}) !' Jjmj014C jmj014C  + *- Z]DJqM5$d7$ &m[$GGNN:x33333rrct||ks|dkrtd|jdkr6tj|jt }t||||||n!|j|}tjd|}tj |jt }tj |||}tjd|dzD]} |dkr8tj || zd|dz } tj || z dd } n || z} || z } tj || |} tj || |} |||| z}|||| z}| r|cS|S) a Calculate the relative extrema of `data`. Relative extrema are calculated by finding locations where ``comparator(data[n], data[n+1:n+order+1])`` is True. Parameters ---------- data : ndarray Array in which to find the relative extrema. comparator : callable Function to use to compare two data points. Should take two arrays as arguments. axis : int, optional Axis over which to select from `data`. Default is 0. order : int, optional How many points on each side to use for the comparison to consider ``comparator(n,n+x)`` to be True. mode : str, optional How the edges of the vector are treated. 'wrap' (wrap around) or 'clip' (treat overflow as the same as the last (or first) element). Default 'clip'. See cupy.take. Returns ------- extrema : ndarray Boolean array of the same shape as `data` that is True at an extrema, False otherwise. See also -------- argrelmax, argrelmin rzOrder must be an int >= 1rr8rr\rN)a_mina_max) rrJrzr;r<r:rUrarangerTtakerr)rrr]rxrrdatalenlocsmainshiftp_locsm_locsplusminuss r _boolrelextremarsD E e4555 y1}}*TZt444dJeT7CCCC*T"{1g&&)DJd333yt$///[EAI..  Ev~~4%>> from cupyx.scipy.signal import argrelmin >>> import cupy >>> x = cupy.array([2, 1, 2, 3, 2, 0, 1, 0]) >>> argrelmin(x) (array([1, 5]),) >>> y = cupy.array([[1, 2, 1, 2], ... [2, 2, 0, 0], ... [5, 3, 4, 4]]) ... >>> argrelmin(y, axis=1) (array([0, 2]), array([2, 1])) )r;ry argrelextremalessrr]rxrs r argrelminr s,n <  D ty$t < <>> from cupyx.scipy.signal import argrelmax >>> import cupy >>> x = cupy.array([2, 1, 2, 3, 2, 0, 1, 0]) >>> argrelmax(x) (array([3, 6]),) >>> y = cupy.array([[1, 2, 1, 2], ... [2, 2, 0, 0], ... [5, 3, 4, 4]]) ... >>> argrelmax(y, axis=1) (array([0]), array([1])) )r;ryrgreaterrs r argrelmaxr[s,h <  D t|T5$ ? ??rctj|}t|||||}|dkrtdtj|S)a Calculate the relative extrema of `data`. Parameters ---------- data : ndarray Array in which to find the relative extrema. comparator : callable Function to use to compare two data points. Should take two arrays as arguments. axis : int, optional Axis over which to select from `data`. Default is 0. order : int, optional How many points on each side to use for the comparison to consider ``comparator(n, n+x)`` to be True. mode : str, optional How the edges of the vector are treated. Available options are 'wrap' (wrap around) or 'clip' (treat overflow as the same as the last (or first) element). Default 'clip'. See cupy.take. Returns ------- extrema : tuple of ndarrays Indices of the maxima in arrays of integers. ``extrema[k]`` is the array of indices of axis `k` of `data`. Note that the return value is a tuple even when `data` is one-dimensional. See Also -------- argrelmin, argrelmax Examples -------- >>> from cupyx.scipy.signal import argrelextrema >>> import cupy >>> x = cupy.array([2, 1, 2, 3, 2, 0, 1, 0]) >>> argrelextrema(x, cupy.greater) (array([3, 6]),) >>> y = cupy.array([[1, 2, 1, 2], ... [2, 2, 0, 0], ... [5, 3, 4, 4]]) ... >>> argrelextrema(y, cupy.less, axis=1) (array([0, 2]), array([2, 1])) raisez+CuPy `take` doesn't support `mode='raise'`.)r;ryrNotImplementedErrornonzero)rrr]rxrrs r rrsY` <  DdJeTBBG w! 9;; ; <  r)NF)F)N)rNN)NNNNNNrN)rrr)=__doc__rr;cupy._core._scalarrcupy_backends.cuda.apircupyxrrrfloat32r FLOAT_TYPESint8int16int32r= INT_TYPESuint8uint16uint32uint64UNSIGNED_TYPESFLOAT_INT_TYPESTYPES TYPE_NAMESFLOAT_INT_NAMESrr less_equal greater_equalequal not_equalr PEAKS_KERNEL RawModuler> ARGREL_KERNELrr5rGrRrZrfrur}rr rawkernelrrrrrrrrrrrrrr rsp6 ++++++******   |T\4<8 Y DJ ; *dk4; D ).( . . . . . ==_=== IqL!OQJNA   m ^t~ BBzBBB22z2223--*---./// ^ B IIIII888889::: ...*,,,^D&>&>&>R???D   420000*%6%6%6%6PT9T9T9T9n[L[L[L[L|9=BE PPPPf4440====@8=8=8=8=v5@5@5@5@p7!7!7!7!7!7!r