0;ji*dZddlmZddlZddlZddlZddlZddl m Z ddl m Z ddl mZdd lmZdd lmZdd lmZmZmZmZmZmZmZmZmZmZdd lmZdd l m!Z!m"Z"m#Z#dZ$gdZ%ddddddZ&e ddd!Z'dd"dd&Z(dd'Z)dd)Z*dd*dd/Z+dd3Z,dd*dd4Z-ddd5d6dd=Z.ed>d>d>d?ddEZ/ed>d>dFddIZ/dddd?ddKZ/e dLej0ddddMddTZ1ej2dUZ3ej2dVZ4ej5gdWdXd5d5YdZZ6ej5gdWdXd5d5Yd[Z7dd*dd\Z8dd*dd]Z9ej5gd^d_d5d5`daZ:d5ddbddjZ;e dLdkddlddqZdddd5dvdd|Z?e dLdd5dd}ddZ@dddddZAddZBddddZCdddddZDejEd5d5`dddddZFdddddZGedeejHejIjJfZKed>d>dddZLed>d>dddZLdddddZLdd*ddZMejNdddZOej=dddZPejEd5d5`dZQdd*ddZRejEd5d5`dZSdd*ddZTejUddgd5d5dddZVeeWdfZXedeeXejHfZYdddZZejUddgd5d5dddZ[ee\ddfZ]ed>dddZ^ed>dddZ^dddd„Z^dS)zUtility functions) annotationsN) as_strided)cache)ParameterError) Deprecated) DTypeLike) AnyCallableListDictOptionalSequenceTupleTypeVarUnionoverload)Literal) _SequenceLike _FloatLike_co_ComplexLike_coi) MAX_MEM_BLOCKframe pad_center expand_to fix_length valid_audio valid_intis_positive_intvalid_intervals fix_frames axis_sortlocalmaxlocalmin normalize peak_pick sparsify_rowsshearstackfill_off_diagonalindex_to_slicesyncsoftmask buf_to_floattinycyclic_gradient dtype_r2c dtype_c2r count_unique is_uniqueabs2phasorF)axis writeablesubokx np.ndarray frame_lengthint hop_lengthr9r:boolr;returnctj|d|}|j||kr"td|j|dd|d|dkrtd|d|jt |j|gz}t |j}||xx|dz zcc<t |t |gz}t|||||} |d kr|dz } n|dz} tj| d | } td g| j z} td d || |<| t | S) aSlice a data array into (overlapping) frames. This implementation uses low-level stride manipulation to avoid making a copy of the data. The resulting frame representation is a new view of the same input data. For example, a one-dimensional input ``x = [0, 1, 2, 3, 4, 5, 6]`` can be framed with frame length 3 and hop length 2 in two ways. The first (``axis=-1``), results in the array ``x_frames``:: [[0, 2, 4], [1, 3, 5], [2, 4, 6]] where each column ``x_frames[:, i]`` contains a contiguous slice of the input ``x[i * hop_length : i * hop_length + frame_length]``. The second way (``axis=0``) results in the array ``x_frames``:: [[0, 1, 2], [2, 3, 4], [4, 5, 6]] where each row ``x_frames[i]`` contains a contiguous slice of the input. This generalizes to higher dimensional inputs, as shown in the examples below. In general, the framing operation increments by 1 the number of dimensions, adding a new "frame axis" either before the framing axis (if ``axis < 0``) or after the framing axis (if ``axis >= 0``). Parameters ---------- x : np.ndarray Array to frame frame_length : int > 0 [scalar] Length of the frame hop_length : int > 0 [scalar] Number of steps to advance between frames axis : int The axis along which to frame. writeable : bool If ``False``, then the framed view of ``x`` is read-only. If ``True``, then the framed view is read-write. Note that writing to the framed view will also write to the input array ``x`` in this case. subok : bool If True, sub-classes will be passed-through, otherwise the returned array will be forced to be a base-class array (default). Returns ------- x_frames : np.ndarray [shape=(..., frame_length, N_FRAMES, ...)] A framed view of ``x``, for example with ``axis=-1`` (framing on the last dimension):: x_frames[..., j] == x[..., j * hop_length : j * hop_length + frame_length] If ``axis=0`` (framing on the first dimension), then:: x_frames[j] = x[j * hop_length : j * hop_length + frame_length] Raises ------ ParameterError If ``x.shape[axis] < frame_length``, there is not enough data to fill one frame. If ``hop_length < 1``, frames cannot advance. See Also -------- numpy.lib.stride_tricks.as_strided Examples -------- Extract 2048-sample frames from monophonic signal with a hop of 64 samples per frame >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> frames = librosa.util.frame(y, frame_length=2048, hop_length=64) >>> frames array([[-1.407e-03, -2.604e-02, ..., -1.795e-05, -8.108e-06], [-4.461e-04, -3.721e-02, ..., -1.573e-05, -1.652e-05], ..., [ 7.960e-02, -2.335e-01, ..., -6.815e-06, 1.266e-05], [ 9.568e-02, -1.252e-01, ..., 7.397e-06, -1.921e-05]], dtype=float32) >>> y.shape (117601,) >>> frames.shape (2048, 1806) Or frame along the first axis instead of the last: >>> frames = librosa.util.frame(y, frame_length=2048, hop_length=64, axis=0) >>> frames.shape (1806, 2048) Frame a stereo signal: >>> y, sr = librosa.load(librosa.ex('trumpet', hq=True), mono=False) >>> y.shape (2, 117601) >>> frames = librosa.util.frame(y, frame_length=2048, hop_length=64) (2, 2048, 1806) Carve an STFT into fixed-length patches of 32 frames with 50% overlap >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> S = np.abs(librosa.stft(y)) >>> S.shape (1025, 230) >>> S_patch = librosa.util.frame(S, frame_length=32, hop_length=16) >>> S_patch.shape (1025, 32, 13) >>> # The first patch contains the first 32 frames of S >>> np.allclose(S_patch[:, :, 0], S[:, :32]) True >>> # The second patch contains frames 16 to 16+32=48, and so on >>> np.allclose(S_patch[:, :, 1], S[:, 16:48]) True F)copyr;zInput is too short (n=dz) for frame_length=rzInvalid hop_length: )stridesshaper;r:rr8N) nparrayrGrrFtuplelistrmoveaxisslicendim) r<r>r@r9r:r; out_stridesx_shape_trimmed out_shapexw target_axisslicess L/root/voice-cloning/.venv/lib/python3.11/site-packages/librosa/util/utils.pyrrGszF e,,,Awt}|## YQWT] Y Y Y Y Y Y   A~~BJBBBCCC)eQYt_$5666K17mmOD\A--o&& ~)>)>>I  ;iu    B axxQh Qh R[ ) )BDkk]RW $FD*--F4L eFmm )levelyclt|tjstdtj|jtjstd|jdkrtd|jtj | stddS)aDetermine whether a variable contains valid audio data. The following conditions must be satisfied: - ``type(y)`` is ``np.ndarray`` - ``y.dtype`` is floating-point - ``y.ndim != 0`` (must have at least one dimension) - ``np.isfinite(y).all()`` samples must be all finite values Parameters ---------- y : np.ndarray The input data to validate Returns ------- valid : bool True if all tests pass Raises ------ ParameterError In any of the conditions specified above fails Notes ----- This function caches at level 20. Examples -------- We can make an array that can be interpreted as an audio signal >>> y = np.random.randn(5000) >>> librosa.util.valid_audio(y) True If we insert a non-finite sample value somewhere, it will fail >>> y[5] = np.nan >>> librosa.util.valid_audio(y) ... ParameterError: Audio buffer is not finite everywhere See Also -------- numpy.float32 z(Audio data must be of type numpy.ndarrayz!Audio data must be floating-pointrz;Audio data must be at least one-dimensional, given y.shape=z%Audio buffer is not finite everywhereT) isinstancerHndarrayr issubdtypedtypefloatingrNrGisfiniteall)rYs rUrrsb a $ $IGHHH ="+ . .B@AAAv{{ S!' S S    ;q>>    FDEEE 4rVcastfloatrc"Optional[Callable[[float], float]]c| tj}t|stdt ||S)aEnsure that an input value is integer-typed. This is primarily useful for ensuring integrable-valued array indices. Parameters ---------- x : number A scalar value to be cast to int cast : function [optional] A function to modify ``x`` before casting. Default: `np.floor` Returns ------- x_int : int ``x_int = int(cast(x))`` Raises ------ ParameterError If ``cast`` is provided and is not callable. Nzcast parameter must be callable)rHfloorcallablerr?)r<rcs rUrr/sB. |x D>>@>??? ttAww<<rVcPt|ttjfo|dkS)zCheck that x is a positive integer, i.e. 1 or greater. Parameters ---------- x : number Returns ------- positive : bool r)r[r?rHintegerr<s rUr r Os$ a#rz* + + 7Q7rV intervalsc|jdks|jddkrtdtj|dddf|dddfkrtd|dd S) aEnsure that an array is a valid representation of time intervals: - intervals.ndim == 2 - intervals.shape[1] == 2 - intervals[i, 0] <= intervals[i, 1] for all i Parameters ---------- intervals : np.ndarray [shape=(n, 2)] set of time intervals Returns ------- valid : bool True if ``intervals`` passes validation. rr8z intervals must have shape (n, 2)Nrrz intervals=z! must have non-negative durationsT)rNrGrrHany)rls rUr!r!^s"~iob1Q66?@@@ vi1o !!!Q$/00XV)VVVWWW 4rVr9datasizekwargsr c |dd|j|}t||z dz}dg|jz}|t||z |z f||<|dkrt d|dd|dd t j||fi|S) a(Pad an array to a target length along a target axis. This differs from `np.pad` by centering the data prior to padding, analogous to `str.center` Examples -------- >>> # Generate a vector >>> data = np.ones(5) >>> librosa.util.pad_center(data, size=10, mode='constant') array([ 0., 0., 1., 1., 1., 1., 1., 0., 0., 0.]) >>> # Pad a matrix along its first dimension >>> data = np.ones((3, 5)) >>> librosa.util.pad_center(data, size=7, axis=0) array([[ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.], [ 1., 1., 1., 1., 1.], [ 1., 1., 1., 1., 1.], [ 1., 1., 1., 1., 1.], [ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.]]) >>> # Or its second dimension >>> librosa.util.pad_center(data, size=7, axis=1) array([[ 0., 1., 1., 1., 1., 1., 0.], [ 0., 1., 1., 1., 1., 1., 0.], [ 0., 1., 1., 1., 1., 1., 0.]]) Parameters ---------- data : np.ndarray Vector to be padded and centered size : int >= len(data) [scalar] Length to pad ``data`` axis : int Axis along which to pad and center the data **kwargs : additional keyword arguments arguments passed to `np.pad` Returns ------- data_padded : np.ndarray ``data`` centered and padded to length ``size`` along the specified axis Raises ------ ParameterError If ``size < data.shape[axis]`` See Also -------- numpy.pad modeconstantrrrrz Target size (rEz) must be at least input size ()) setdefaultrGr?rNrrHpad)rprqr9rrnlpadlengthss rUrrxsr fj))) 4A qQ  Dh"G3tax$//0GDM axx ID I I I1 I I I I    6$ * *6 * **rVrNaxes1Union[int, slice, Sequence[int], Sequence[slice]]c t|}n #t$rt|g}YnwxYwt||jkrt d|d|j||jkrt d|jd|dg|z}t |D]\}}|j|||<||S)aExpand the dimensions of an input array with Parameters ---------- x : np.ndarray The input array ndim : int The number of dimensions to expand to. Must be at least ``x.ndim`` axes : int or slice The target axis or axes to preserve from x. All other axes will have length 1. Returns ------- x_exp : np.ndarray The expanded version of ``x``, satisfying the following: ``x_exp[axes] == x`` ``x_exp.ndim == ndim`` See Also -------- np.expand_dims Examples -------- Expand a 1d array into an (n, 1) shape >>> x = np.arange(3) >>> librosa.util.expand_to(x, ndim=2, axes=0) array([[0], [1], [2]]) Expand a 1d array into a (1, n) shape >>> librosa.util.expand_to(x, ndim=2, axes=1) array([[0, 1, 2]]) Expand a 2d array into (1, n, m, 1) shape >>> x = np.vander(np.arange(3)) >>> librosa.util.expand_to(x, ndim=4, axes=[1,2]).shape (1, 3, 3, 1) zShape mismatch between axes=z and input x.shape=zCannot expand x.shape=z to fewer dimensions ndim=r)rJ TypeErrorlenrNrrG enumeratereshape)r<rNr}axes_tuprGiaxis rUrrsb!;; !!!$==! 8}} Q8 Q Q Q Q    af}} NQW N N N N   sTzEH%%  3WQZc 99U  s //c 4|dd|j|}||kr@tdg|jz}td|||<|t |S||kr(dg|jz}d||z f||<t j||fi|S|S)amFix the length an array ``data`` to exactly ``size`` along a target axis. If ``data.shape[axis] < n``, pad according to the provided kwargs. By default, ``data`` is padded with trailing zeros. Examples -------- >>> y = np.arange(7) >>> # Default: pad with zeros >>> librosa.util.fix_length(y, size=10) array([0, 1, 2, 3, 4, 5, 6, 0, 0, 0]) >>> # Trim to a desired length >>> librosa.util.fix_length(y, size=5) array([0, 1, 2, 3, 4]) >>> # Use edge-padding instead of zeros >>> librosa.util.fix_length(y, size=10, mode='edge') array([0, 1, 2, 3, 4, 5, 6, 6, 6, 6]) Parameters ---------- data : np.ndarray array to be length-adjusted size : int >= 0 [scalar] desired length of the array axis : int, <= data.ndim axis along which to fix length **kwargs : additional keyword arguments Parameters to ``np.pad`` Returns ------- data_fixed : np.ndarray [shape=data.shape] ``data`` either trimmed or padded to length ``size`` along the specified axis. See Also -------- numpy.pad rtruNrrv)rxrGrMrNrJrHry)rprqr9rrrzrTr|s rUrr sT fj))) 4A4xx++*Q~~t E&MM"" T(TY&D1H  vdG..v... KrVTx_minx_maxryframes_SequenceLike[int]r Optional[int]rryctj|}tj|dkrtd|r||tj|||}|rXg}||||||tjtj||f}| |||k}| |||k}tj|t}|S)avFix a list of frames to lie within [x_min, x_max] Examples -------- >>> # Generate a list of frame indices >>> frames = np.arange(0, 1000.0, 50) >>> frames array([ 0., 50., 100., 150., 200., 250., 300., 350., 400., 450., 500., 550., 600., 650., 700., 750., 800., 850., 900., 950.]) >>> # Clip to span at most 250 >>> librosa.util.fix_frames(frames, x_max=250) array([ 0, 50, 100, 150, 200, 250]) >>> # Or pad to span up to 2500 >>> librosa.util.fix_frames(frames, x_max=2500) array([ 0, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500, 550, 600, 650, 700, 750, 800, 850, 900, 950, 2500]) >>> librosa.util.fix_frames(frames, x_max=2500, pad=False) array([ 0, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500, 550, 600, 650, 700, 750, 800, 850, 900, 950]) >>> # Or starting away from zero >>> frames = np.arange(200, 500, 33) >>> frames array([200, 233, 266, 299, 332, 365, 398, 431, 464, 497]) >>> librosa.util.fix_frames(frames) array([ 0, 200, 233, 266, 299, 332, 365, 398, 431, 464, 497]) >>> librosa.util.fix_frames(frames, x_max=500) array([ 0, 200, 233, 266, 299, 332, 365, 398, 431, 464, 497, 500]) Parameters ---------- frames : np.ndarray [shape=(n_frames,)] List of non-negative frame indices x_min : int >= 0 or None Minimum allowed frame index x_max : int >= 0 or None Maximum allowed frame index pad : boolean If ``True``, then ``frames`` is expanded to span the full range ``[x_min, x_max]`` Returns ------- fixed_frames : np.ndarray [shape=(n_fixed_frames,), dtype=int] Fixed frame indices, flattened and sorted Raises ------ ParameterError If ``frames`` contains negative values rzNegative frame index detected) rHasarrayrnrclipappend concatenateuniqueastyper?)rrrrypad_datars rUr"r"DszZ  F vfqj><=== /!U%6.. @   OOE " " "   OOE " " "H!5!5v >?? %( %(6**11#66F MrV.)r9indexvalueSrLiteral[False]rOptional[Callable[..., Any]]cdSNrr9rrs rUr#r# CrV)r9r Literal[True]Tuple[np.ndarray, np.ndarray]cdSrrrs rUr#r#rrV0Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]c`| tj}|jdkrtd||tjd|z |j}tj|}t dg|jz}|||<|r|t||fS|t|S)a6 Sort an array along its rows or columns. Examples -------- Visualize NMF output for a spectrogram S >>> # Sort the columns of W by peak frequency bin >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> S = np.abs(librosa.stft(y)) >>> W, H = librosa.decompose.decompose(S, n_components=64) >>> W_sort = librosa.util.axis_sort(W) Or sort by the lowest frequency bin >>> W_sort = librosa.util.axis_sort(W, value=np.argmin) Or sort the rows instead of the columns >>> W_sort_rows = librosa.util.axis_sort(W, axis=0) Get the sorting index also, and use it to permute the rows of H >>> W_sort, idx = librosa.util.axis_sort(W, index=True) >>> H_sort = H[idx, :] >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(nrows=2, ncols=2) >>> img_w = librosa.display.specshow(librosa.amplitude_to_db(W, ref=np.max), ... y_axis='log', ax=ax[0, 0]) >>> ax[0, 0].set(title='W') >>> ax[0, 0].label_outer() >>> img_act = librosa.display.specshow(H, x_axis='time', ax=ax[0, 1]) >>> ax[0, 1].set(title='H') >>> ax[0, 1].label_outer() >>> librosa.display.specshow(librosa.amplitude_to_db(W_sort, ... ref=np.max), ... y_axis='log', ax=ax[1, 0]) >>> ax[1, 0].set(title='W sorted') >>> librosa.display.specshow(H_sort, x_axis='time', ax=ax[1, 1]) >>> ax[1, 1].set(title='H sorted') >>> ax[1, 1].label_outer() >>> fig.colorbar(img_w, ax=ax[:, 0], orientation='horizontal') >>> fig.colorbar(img_act, ax=ax[:, 1], orientation='horizontal') Parameters ---------- S : np.ndarray [shape=(d, n)] Array to be sorted axis : int [scalar] The axis along which to compute the sorting values - ``axis=0`` to sort rows by peak column index - ``axis=1`` to sort columns by peak row index index : boolean [scalar] If true, returns the index array as well as the permuted data. value : function function to return the index corresponding to the sort order. Default: `np.argmax`. Returns ------- S_sort : np.ndarray [shape=(d, n)] ``S`` with the columns or rows permuted in sorting order idx : np.ndarray (optional) [shape=(d,) or (n,)] If ``index == True``, the sorting index used to permute ``S``. Length of ``idx`` corresponds to the selected ``axis``. Raises ------ ParameterError If ``S`` does not have exactly 2 dimensions (``S.ndim != 2``) Nrz'axis_sort is only defined for 2D arraysrro)rHargmaxrNrmodargsortrMrJ)rr9rrbin_idxidx sort_slices rUr#r#sd } v{{FGGGeABF1t8QV44555G *W  C++'JJt $z""#S((z""##rV()normr9 thresholdfillrOptional[float]rOptional[_FloatLike_co]rOptional[bool]c|t|}n|dkrtd|d|dvrtd|dtjtj|stdtj|t}d }||S|tjkrtj ||d }n|tj krtj ||d }n|dkr5|d urtd tj |dk|d |j }ntj t|tjrJ|dkrDtj ||z|d d|z z}||jd|z z}n3|j|d|z z}ntdt%|||k}tj|} |d||<||z | dd<nL|r1tj||<||z | dd<|| tj| <ntj||<||z | dd<| S)aNormalize an array along a chosen axis. Given a norm (described below) and a target axis, the input array is scaled so that:: norm(S, axis=axis) == 1 For example, ``axis=0`` normalizes each column of a 2-d array by aggregating over the rows (0-axis). Similarly, ``axis=1`` normalizes each row of a 2-d array. This function also supports thresholding small-norm slices: any slice (i.e., row or column) with norm below a specified ``threshold`` can be left un-normalized, set to all-zeros, or filled with uniform non-zero values that normalize to 1. Note: the semantics of this function differ from `scipy.linalg.norm` in two ways: multi-dimensional arrays are supported, but matrix-norms are not. Parameters ---------- S : np.ndarray The array to normalize norm : {np.inf, -np.inf, 0, float > 0, None} - `np.inf` : maximum absolute value - `-np.inf` : minimum absolute value - `0` : number of non-zeros (the support) - float : corresponding l_p norm See `scipy.linalg.norm` for details. - None : no normalization is performed axis : int [scalar] Axis along which to compute the norm. threshold : number > 0 [optional] Only the columns (or rows) with norm at least ``threshold`` are normalized. By default, the threshold is determined from the numerical precision of ``S.dtype``. fill : None or bool If None, then columns (or rows) with norm below ``threshold`` are left as is. If False, then columns (rows) with norm below ``threshold`` are set to 0. If True, then columns (rows) with norm below ``threshold`` are filled uniformly such that the corresponding norm is 1. .. note:: ``fill=True`` is incompatible with ``norm=0`` because no uniform vector exists with l0 "norm" equal to 1. Returns ------- S_norm : np.ndarray [shape=S.shape] Normalized array Raises ------ ParameterError If ``norm`` is not among the valid types defined above If ``S`` is not finite If ``fill=True`` and ``norm=0`` See Also -------- scipy.linalg.norm Notes ----- This function caches at level 40. Examples -------- >>> # Construct an example matrix >>> S = np.vander(np.arange(-2.0, 2.0)) >>> S array([[-8., 4., -2., 1.], [-1., 1., -1., 1.], [ 0., 0., 0., 1.], [ 1., 1., 1., 1.]]) >>> # Max (l-infinity)-normalize the columns >>> librosa.util.normalize(S) array([[-1. , 1. , -1. , 1. ], [-0.125, 0.25 , -0.5 , 1. ], [ 0. , 0. , 0. , 1. ], [ 0.125, 0.25 , 0.5 , 1. ]]) >>> # Max (l-infinity)-normalize the rows >>> librosa.util.normalize(S, axis=1) array([[-1. , 0.5 , -0.25 , 0.125], [-1. , 1. , -1. , 1. ], [ 0. , 0. , 0. , 1. ], [ 1. , 1. , 1. , 1. ]]) >>> # l1-normalize the columns >>> librosa.util.normalize(S, norm=1) array([[-0.8 , 0.667, -0.5 , 0.25 ], [-0.1 , 0.167, -0.25 , 0.25 ], [ 0. , 0. , 0. , 0.25 ], [ 0.1 , 0.167, 0.25 , 0.25 ]]) >>> # l2-normalize the columns >>> librosa.util.normalize(S, norm=2) array([[-0.985, 0.943, -0.816, 0.5 ], [-0.123, 0.236, -0.408, 0.5 ], [ 0. , 0. , 0. , 0.5 ], [ 0.123, 0.236, 0.408, 0.5 ]]) >>> # Thresholding and filling >>> S[:, -1] = 1e-308 >>> S array([[ -8.000e+000, 4.000e+000, -2.000e+000, 1.000e-308], [ -1.000e+000, 1.000e+000, -1.000e+000, 1.000e-308], [ 0.000e+000, 0.000e+000, 0.000e+000, 1.000e-308], [ 1.000e+000, 1.000e+000, 1.000e+000, 1.000e-308]]) >>> # By default, small-norm columns are left untouched >>> librosa.util.normalize(S) array([[ -1.000e+000, 1.000e+000, -1.000e+000, 1.000e-308], [ -1.250e-001, 2.500e-001, -5.000e-001, 1.000e-308], [ 0.000e+000, 0.000e+000, 0.000e+000, 1.000e-308], [ 1.250e-001, 2.500e-001, 5.000e-001, 1.000e-308]]) >>> # Small-norm columns can be zeroed out >>> librosa.util.normalize(S, fill=False) array([[-1. , 1. , -1. , 0. ], [-0.125, 0.25 , -0.5 , 0. ], [ 0. , 0. , 0. , 0. ], [ 0.125, 0.25 , 0.5 , 0. ]]) >>> # Or set to constant with unit-norm >>> librosa.util.normalize(S, fill=True) array([[-1. , 1. , -1. , 1. ], [-0.125, 0.25 , -0.5 , 1. ], [ 0. , 0. , 0. , 1. ], [ 0.125, 0.25 , 0.5 , 1. ]]) >>> # With an l1 norm instead of max-norm >>> librosa.util.normalize(S, norm=1, fill=True) array([[-0.8 , 0.667, -0.5 , 0.25 ], [-0.1 , 0.167, -0.25 , 0.25 ], [ 0. , 0. , 0. , 0.25 ], [ 0.1 , 0.167, 0.25 , 0.25 ]]) Nrz threshold=z must be strictly positive)NFTzfill=z must be None or booleanzInput must be finiterTr9keepdimsz*Cannot normalize with norm=0 and fill=True)r9rr^?gzUnsupported norm: )r0rrHrar`absrrdinfmaxminsumr^r]typenumberrqrGrepr empty_likenanisnan) rrr9rrmag fill_normlength small_idxSnorms rUr&r&srFGG aO)OOOPPP &&&CTCCCDDD 6"+a.. ! !53444 &))  5 ! !CI | $666 "&$666  4<< !MNN NadTKKK tDzz29 - - @$((T t<<<tL <TD[1II $D4K8II>$t**>>???"I M!  E |yv:aaa Fyv:aaa!*bhuooFyv:aaa LrVcL|d|dk|d|dkzS)z*Numba stencil for local maxima computationrr8rrrks rU_localmax_stenr' aD1R5LQqTQqT\ **rVcL|d|dk|d|dkzS)z*Numba stencil for local minima computationrr8rrrks rU_localmin_stenrrrV)zvoid(int16[:], bool_[:])zvoid(int32[:], bool_[:])zvoid(int64[:], bool_[:])zvoid(float32[:], bool_[:])zvoid(float64[:], bool_[:])z(n)->(n))rnopythonc.t||dd<dS)z+Vectorized wrapper for the localmax stencilN)rr<rYs rU _localmaxr  !  AaaaDDDrVc.t||dd<dS)z+Vectorized wrapper for the localmin stencilN)rrs rU _localminrrrVc|d|}tj|t}|d|}t |||d|dk|d<|S)aFind local maxima in an array An element ``x[i]`` is considered a local maximum if the following conditions are met: - ``x[i] > x[i-1]`` - ``x[i] >= x[i+1]`` Note that the first condition is strict, and that the first element ``x[0]`` will never be considered as a local maximum. Examples -------- >>> x = np.array([1, 0, 1, 2, -1, 0, -2, 1]) >>> librosa.util.localmax(x) array([False, False, False, True, False, True, False, True], dtype=bool) >>> # Two-dimensional example >>> x = np.array([[1,0,1], [2, -1, 0], [2, 1, 3]]) >>> librosa.util.localmax(x, axis=0) array([[False, False, False], [ True, False, False], [False, True, True]], dtype=bool) >>> librosa.util.localmax(x, axis=1) array([[False, False, True], [False, False, True], [False, False, True]], dtype=bool) Parameters ---------- x : np.ndarray [shape=(d1,d2,...)] input vector or array axis : int axis along which to compute local maximality Returns ------- m : np.ndarray [shape=x.shape, dtype=bool] indicator array of local maximality along ``axis`` See Also -------- localmin r8r^.r8.)swapaxesrHrrAr)r<r9xilmaxlmaxis rUr$r$-sp\ B  B =$ ' ' 'D MM"d # #Eb%[2g;.E'N KrVc|d|}tj|t}|d|}t |||d|dk|d<|S)aFind local minima in an array An element ``x[i]`` is considered a local minimum if the following conditions are met: - ``x[i] < x[i-1]`` - ``x[i] <= x[i+1]`` Note that the first condition is strict, and that the first element ``x[0]`` will never be considered as a local minimum. Examples -------- >>> x = np.array([1, 0, 1, 2, -1, 0, -2, 1]) >>> librosa.util.localmin(x) array([False, True, False, False, True, False, True, False]) >>> # Two-dimensional example >>> x = np.array([[1,0,1], [2, -1, 0], [2, 1, 3]]) >>> librosa.util.localmin(x, axis=0) array([[False, False, False], [False, True, True], [False, False, False]]) >>> librosa.util.localmin(x, axis=1) array([[False, True, False], [False, True, False], [False, True, False]]) Parameters ---------- x : np.ndarray [shape=(d1,d2,...)] input vector or array axis : int axis along which to compute local minimality Returns ------- m : np.ndarray [shape=x.shape, dtype=bool] indicator array of local minimality along ``axis`` See Also -------- localmax r8rrr)rrHrrAr)r<r9rlminlminis rUr%r%jsp^ B  B =$ ' ' 'D MM"d # #Eb%[2g;.E'N KrV)zKvoid(float32[:], uint32, uint32, uint32, uint32, float32, uint32, bool_[:])zKvoid(float64[:], uint32, uint32, uint32, uint32, float32, uint32, bool_[:])zIvoid(int32[:], uint32, uint32, uint32, uint32, float32, uint32, bool_[:])zIvoid(int64[:], uint32, uint32, uint32, uint32, float32, uint32, bool_[:])z(n),(),(),(),(),(),()->(n))rrc V|dtj|dt||jdk|d<|dxx|dtj|dt||jd|zkzcc<|dr|dz}nd}||jdkrtj|td||z t||z|jd} ||| k||<||s|dz }wtj|td||z t||z|jd} ||xx||| |zkzcc<||s|dz }||dzz }||jdkdSdS)z&Vectorized wrapper for the peak-pickerrNr)rHrrrGmean) r<pre_maxpost_maxpre_avgpost_avgdeltawaitpeaksrzmaxnavgns rU __peak_pickrs!q!;#h ";";!;<===E!H !HHH1#=C!'!*$=$=#=!>??%GGHHHH Qx 1H  agaj..vqQ' **3qz171:+F+FFGHHaDDLaQx  FA wqQ' **3qz171:+F+FFGHH aQqTTE\)*Qx  FA  TAX % agaj......rV)sparser9rrrrrrrc 8|dkrtd|dkrtd|dkrtd|dkrtd|dkrtd|dkrtd|r#|jdkrtd |jd t|tj }t|tj }t|tj }t|tj }t|tj }tj|t } t||d ||||||| |d |rtj | S| S)a Use a flexible heuristic to pick peaks in a signal. A sample n is selected as an peak if the corresponding ``x[n]`` fulfills the following three conditions: 1. ``x[n] == max(x[n - pre_max:n + post_max])`` 2. ``x[n] >= mean(x[n - pre_avg:n + post_avg]) + delta`` 3. ``n - previous_n > wait`` where ``previous_n`` is the last sample picked as a peak (greedily). This implementation is based on [#]_ and [#]_. .. [#] Boeck, Sebastian, Florian Krebs, and Markus Schedl. "Evaluating the Online Capabilities of Onset Detection Methods." ISMIR. 2012. .. [#] https://github.com/CPJKU/onset_detection/blob/master/onset_program.py Parameters ---------- x : np.ndarray input signal to peak picks from pre_max : int >= 0 [scalar] number of samples before ``n`` over which max is computed post_max : int >= 1 [scalar] number of samples after ``n`` over which max is computed pre_avg : int >= 0 [scalar] number of samples before ``n`` over which mean is computed post_avg : int >= 1 [scalar] number of samples after ``n`` over which mean is computed delta : float >= 0 [scalar] threshold offset for mean wait : int >= 0 [scalar] number of samples to wait after picking a peak sparse : bool [scalar] If `True`, the output are indices of detected peaks. If `False`, the output is a dense boolean array of the same shape as ``x``. axis : int [scalar] the axis over which to detect peaks. Returns ------- peaks : np.ndarray [shape=(n_peaks,) or shape=x.shape, dtype=int or bool] indices of peaks in ``x`` (sparse=True) or a boolean array where `peaks[..., n]` indicates a peak at frame index `n` (sparse=False) Raises ------ ParameterError If any input lies outside its defined range Examples -------- >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> onset_env = librosa.onset.onset_strength(y=y, sr=sr, ... hop_length=512, ... aggregate=np.median) >>> peaks = librosa.util.peak_pick(onset_env, pre_max=3, post_max=3, pre_avg=3, post_avg=5, delta=0.5, wait=10) >>> peaks array([ 3, 27, 40, 61, 72, 88, 103]) Using dense output to make a boolean array of peak indicators >>> librosa.util.peak_pick(onset_env, pre_max=3, post_max=3, pre_avg=3, post_avg=5, ... delta=0.5, wait=10, sparse=False) array([False, False, ..., False, False]) >>> import matplotlib.pyplot as plt >>> times = librosa.times_like(onset_env, sr=sr, hop_length=512) >>> fig, ax = plt.subplots(nrows=2, sharex=True) >>> D = np.abs(librosa.stft(y)) >>> librosa.display.specshow(librosa.amplitude_to_db(D, ref=np.max), ... y_axis='log', x_axis='time', ax=ax[1]) >>> ax[0].plot(times, onset_env, alpha=0.8, label='Onset strength') >>> ax[0].vlines(times[peaks], 0, ... onset_env.max(), color='r', alpha=0.8, ... label='Selected peaks') >>> ax[0].legend(frameon=True, framealpha=0.8) >>> ax[0].label_outer() rzpre_max must be non-negativezpre_avg must be non-negativezdelta must be non-negativezwait must be non-negativezpost_max must be positivezpost_avg must be positiverz'sparse=True (default) does not support zU-dimensional inputs. Either set sparse=False or process each dimension independently.rbrr8) rrNrrHceil zeros_likerArr flatnonzero) r<rrrrrrrr9rs rUr'r'sz{{;<<<{{;<<< qyy9::: axx89991}}89991}}8999 U!&A++T6TTTUU U bg...G000Hbg...G000H T ( ( (D M!4 ( ( (E 4$$gx(ESWY^YgYghlnpYqYqrrr %~e$$$ LrVg{Gz?)quantiler^rr^Optional[DTypeLike]scipy.sparse.csr_matrixc|jdkr|d}n#|jdkrtd|jdd|cxkrdksntd|d||j}t j|j| }tj |}tj |dd }tj |d }tj ||z d }tj ||kd }t|D]:\} } tj|| || | fk} || | f|| | f<;|S)a~ Return a row-sparse matrix approximating the input Parameters ---------- x : np.ndarray [ndim <= 2] The input matrix to sparsify. quantile : float in [0, 1.0) Percentage of magnitude to discard in each row of ``x`` dtype : np.dtype, optional The dtype of the output array. If not provided, then ``x.dtype`` will be used. Returns ------- x_sparse : ``scipy.sparse.csr_matrix`` [shape=x.shape] Row-sparsified approximation of ``x`` If ``x.ndim == 1``, then ``x`` is interpreted as a row vector, and ``x_sparse.shape == (1, len(x))``. Raises ------ ParameterError If ``x.ndim > 2`` If ``quantile`` lies outside ``[0, 1.0)`` Notes ----- This function caches at level 40. Examples -------- >>> # Construct a Hann window to sparsify >>> x = scipy.signal.hann(32) >>> x array([ 0. , 0.01 , 0.041, 0.09 , 0.156, 0.236, 0.326, 0.424, 0.525, 0.625, 0.72 , 0.806, 0.879, 0.937, 0.977, 0.997, 0.997, 0.977, 0.937, 0.879, 0.806, 0.72 , 0.625, 0.525, 0.424, 0.326, 0.236, 0.156, 0.09 , 0.041, 0.01 , 0. ]) >>> # Discard the bottom percentile >>> x_sparse = librosa.util.sparsify_rows(x, quantile=0.01) >>> x_sparse <1x32 sparse matrix of type '' with 26 stored elements in Compressed Sparse Row format> >>> x_sparse.todense() matrix([[ 0. , 0. , 0. , 0.09 , 0.156, 0.236, 0.326, 0.424, 0.525, 0.625, 0.72 , 0.806, 0.879, 0.937, 0.977, 0.997, 0.997, 0.977, 0.937, 0.879, 0.806, 0.72 , 0.625, 0.525, 0.424, 0.326, 0.236, 0.156, 0.09 , 0. , 0. , 0. ]]) >>> # Discard up to the bottom 10th percentile >>> x_sparse = librosa.util.sparsify_rows(x, quantile=0.1) >>> x_sparse <1x32 sparse matrix of type '' with 20 stored elements in Compressed Sparse Row format> >>> x_sparse.todense() matrix([[ 0. , 0. , 0. , 0. , 0. , 0. , 0.326, 0.424, 0.525, 0.625, 0.72 , 0.806, 0.879, 0.937, 0.977, 0.997, 0.997, 0.977, 0.937, 0.879, 0.806, 0.72 , 0.625, 0.525, 0.424, 0.326, 0. , 0. , 0. , 0. , 0. , 0. ]]) r)rr8rz8Input must have 2 or fewer dimensions. Provided x.shape=.zInvalid quantile z.2fNrTrro)rNrrrGr^scipyr lil_matrixrHrrsortcumsumargminrwheretocsr) r<rr^x_sparsemagsnormsmag_sortcumulative_mag threshold_idxrjrs rUr(r(PsH v{{ IIg   ! Qqw Q Q Q    (    Q    ????@@@ }|&&qwe&<>  rV)n_bytesr^rr cdtdd|zdz zz }d|d}|tj|||zS)aConvert an integer buffer to floating point values. This is primarily useful when loading integer-valued wav data into numpy arrays. Parameters ---------- x : np.ndarray [dtype=int] The integer-valued data buffer n_bytes : int [1, 2, 4] The number of bytes per sample in ``x`` dtype : numeric type The target output type (default: 32-bit float) Returns ------- x_float : np.ndarray [dtype=float] The input data buffer cast to floating point rrz>> # Generate slices from spaced indices >>> librosa.util.index_to_slice(np.arange(20, 100, 15)) [slice(20, 35, None), slice(35, 50, None), slice(50, 65, None), slice(65, 80, None), slice(80, 95, None)] >>> # Pad to span the range (0, 100) >>> librosa.util.index_to_slice(np.arange(20, 100, 15), ... idx_min=0, idx_max=100) [slice(0, 20, None), slice(20, 35, None), slice(35, 50, None), slice(50, 65, None), slice(65, 80, None), slice(80, 95, None), slice(95, 100, None)] >>> # Use a step of 5 for each slice >>> librosa.util.index_to_slice(np.arange(20, 100, 15), ... idx_min=0, idx_max=100, step=5) [slice(0, 20, 5), slice(20, 35, 5), slice(35, 50, 5), slice(50, 65, 5), slice(65, 80, 5), slice(80, 95, 5), slice(95, 100, 5)] rc8g|]\}}t||Sr)rM).0startendr s rU z"index_to_slice.. s) V V V E%d # # V V VrVrN)r"zip)rr r r ry idx_fixeds ` rUr,r,sNh3gW#FFFI W V V VIyQRQSQS}8U8U V V VVrV) aggregateryr9%Union[Sequence[int], Sequence[slice]]rc| tj}t|j}tjd|Dr|}n\tjd|Dr,t tj|d|||}ntd|t|}t|||<tj |tj |rdnd|j }tdg|j z} tdg|j z} t|D]?\} } | | |<| | |<||t| | |t| <@|S) a Aggregate a multi-dimensional array between specified boundaries. .. note:: In order to ensure total coverage, boundary points may be added to ``idx``. If synchronizing a feature matrix against beat tracker output, ensure that frame index numbers are properly aligned and use the same hop length. Parameters ---------- data : np.ndarray multi-dimensional array of features idx : sequence of ints or slices Either an ordered array of boundary indices, or an iterable collection of slice objects. aggregate : function aggregation function (default: `np.mean`) pad : boolean If `True`, ``idx`` is padded to span the full range ``[0, data.shape[axis]]`` axis : int The axis along which to aggregate data Returns ------- data_sync : ndarray ``data_sync`` will have the same dimension as ``data``, except that the ``axis`` coordinate will be reduced according to ``idx``. For example, a 2-dimensional ``data`` with ``axis=-1`` should satisfy:: data_sync[:, i] = aggregate(data[:, idx[i-1]:idx[i]], axis=-1) Raises ------ ParameterError If the index set is not of consistent type (all slices or all integers) Notes ----- This function caches at level 40. Examples -------- Beat-synchronous CQT spectra >>> y, sr = librosa.load(librosa.ex('choice')) >>> tempo, beats = librosa.beat.beat_track(y=y, sr=sr, trim=False) >>> C = np.abs(librosa.cqt(y=y, sr=sr)) >>> beats = librosa.util.fix_frames(beats) By default, use mean aggregation >>> C_avg = librosa.util.sync(C, beats) Use median-aggregation instead of mean >>> C_med = librosa.util.sync(C, beats, ... aggregate=np.median) Or sub-beat synchronization >>> sub_beats = librosa.segment.subsegment(C, beats) >>> sub_beats = librosa.util.fix_frames(sub_beats) >>> C_med_sub = librosa.util.sync(C, sub_beats, aggregate=np.median) Plot the results >>> import matplotlib.pyplot as plt >>> beat_t = librosa.frames_to_time(beats, sr=sr) >>> subbeat_t = librosa.frames_to_time(sub_beats, sr=sr) >>> fig, ax = plt.subplots(nrows=3, sharex=True, sharey=True) >>> librosa.display.specshow(librosa.amplitude_to_db(C, ... ref=np.max), ... x_axis='time', ax=ax[0]) >>> ax[0].set(title='CQT power, shape={}'.format(C.shape)) >>> ax[0].label_outer() >>> librosa.display.specshow(librosa.amplitude_to_db(C_med, ... ref=np.max), ... x_coords=beat_t, x_axis='time', ax=ax[1]) >>> ax[1].set(title='Beat synchronous CQT power, ' ... 'shape={}'.format(C_med.shape)) >>> ax[1].label_outer() >>> librosa.display.specshow(librosa.amplitude_to_db(C_med_sub, ... ref=np.max), ... x_coords=subbeat_t, x_axis='time', ax=ax[2]) >>> ax[2].set(title='Sub-beat synchronous CQT power, ' ... 'shape={}'.format(C_med_sub.shape)) Nc8g|]}t|tSr)r[rMr_s rUrzsync..ss"111z!U##111rVcfg|].}tjt|tj/Sr)rHr]rrjrs rUrzsync..us,AAAtAww 33AAArVr)r r ryzInvalid index set: FC)orderr^ro)rHrrKrGrar,rrrempty isfortranr^rMrNrrJ) rprrryr9rGrT agg_shapedata_aggidx_inidx_aggrsegments rUr-r- sDG   E v11S11122: AASAAA B B: JsOOQd    8388999U I&kkIdOx T 2 2;4:HDkk]TY &FT{{mhm+G''MM 7t  #,9T%---@t#L#L#Lw  OrV)power split_zerosXX_refr&r'c|j|jkrtd|jd|jtj|dkstj|dkrtd|dkrtd|j}tj|tjs tj}tj|| |}|tj |j k}d||<tj |r@||z |z}||z |z}|} || xx|| || zzcc<|rd||<n d||<n||k}|S) au Robustly compute a soft-mask operation. ``M = X**power / (X**power + X_ref**power)`` Parameters ---------- X : np.ndarray The (non-negative) input array corresponding to the positive mask elements X_ref : np.ndarray The (non-negative) array of reference or background elements. Must have the same shape as ``X``. power : number > 0 or np.inf If finite, returns the soft mask computed in a numerically stable way If infinite, returns a hard (binary) mask equivalent to ``X > X_ref``. Note: for hard masks, ties are always broken in favor of ``X_ref`` (``mask=0``). split_zeros : bool If `True`, entries where ``X`` and ``X_ref`` are both small (close to 0) will receive mask values of 0.5. Otherwise, the mask is set to 0 for these entries. Returns ------- mask : np.ndarray, shape=X.shape The output mask array Raises ------ ParameterError If ``X`` and ``X_ref`` have different shapes. If ``X`` or ``X_ref`` are negative anywhere If ``power <= 0`` Examples -------- >>> X = 2 * np.ones((3, 3)) >>> X_ref = np.vander(np.arange(3.0)) >>> X array([[ 2., 2., 2.], [ 2., 2., 2.], [ 2., 2., 2.]]) >>> X_ref array([[ 0., 0., 1.], [ 1., 1., 1.], [ 4., 2., 1.]]) >>> librosa.util.softmask(X, X_ref, power=1) array([[ 1. , 1. , 0.667], [ 0.667, 0.667, 0.667], [ 0.333, 0.5 , 0.667]]) >>> librosa.util.softmask(X_ref, X, power=1) array([[ 0. , 0. , 0.333], [ 0.333, 0.333, 0.333], [ 0.667, 0.5 , 0.333]]) >>> librosa.util.softmask(X, X_ref, power=2) array([[ 1. , 1. , 0.8], [ 0.8, 0.8, 0.8], [ 0.2, 0.5, 0.8]]) >>> librosa.util.softmask(X, X_ref, power=4) array([[ 1. , 1. , 0.941], [ 0.941, 0.941, 0.941], [ 0.059, 0.5 , 0.941]]) >>> librosa.util.softmask(X, X_ref, power=100) array([[ 1.000e+00, 1.000e+00, 1.000e+00], [ 1.000e+00, 1.000e+00, 1.000e+00], [ 7.889e-31, 5.000e-01, 1.000e+00]]) >>> librosa.util.softmask(X, X_ref, power=np.inf) array([[ True, True, True], [ True, True, True], [False, False, True]], dtype=bool) zShape mismatch: z!=rz X and X_ref must be non-negativezpower must be strictly positiverg?r) rGrrHrnr^r]r_float32maximumrfinfor0r`) r(r)r&r'r^Zbad_idxmaskref_maskgood_idxs rUr.r.sw^ w%+HHH5;HHIII va!e}}Auqy))A?@@@ zz>??? GE = , ,  1e##E**A"(5//&&GAgJ  {5 A%AI%'8 X$x.8H+===  DMMDMM5y KrVUnion[float, np.ndarray]rc8tj|}tj|jtjs$tj|jtjr|j}ntjtj}tj|jS)aCompute the tiny-value corresponding to an input's data type. This is the smallest "usable" number representable in ``x.dtype`` (e.g., float32). This is primarily useful for determining a threshold for numerical underflow in division or multiplication operations. Parameters ---------- x : number or np.ndarray The array to compute the tiny-value for. All that matters here is ``x.dtype`` Returns ------- tiny_value : float The smallest positive usable number for the type of ``x``. If ``x`` is integer-typed, then the tiny value for ``np.float32`` is returned instead. See Also -------- numpy.finfo Examples -------- For a standard double-precision floating point number: >>> librosa.util.tiny(1.0) 2.2250738585072014e-308 Or explicitly as double-precision >>> librosa.util.tiny(np.asarray(1e-5, dtype=np.float64)) 2.2250738585072014e-308 Or complex numbers >>> librosa.util.tiny(1j) 2.2250738585072014e-308 Single-precision floating point: >>> librosa.util.tiny(np.asarray(1e-5, dtype=np.float32)) 1.1754944e-38 Integer >>> librosa.util.tiny(5) 1.1754944e-38 ) rHrr]r^r_complexfloatingr+r-r0)r<r^s rUr0r0svl 1 A }QWbk**%bm #//%$$ 8E?? rV)rradiusNonec|j\}}ttj|tj|jz}|j\}}tj|jd|jdz }||kr1tj|||z}tj|| }n0tj||}tj|| |z }|||<|||<dS)a/Set all cells of a matrix to a given ``value`` if they lie outside a constraint region. In this case, the constraint region is the Sakoe-Chiba band which runs with a fixed ``radius`` along the main diagonal. When ``x.shape[0] != x.shape[1]``, the radius will be expanded so that ``x[-1, -1] = 1`` always. ``x`` will be modified in place. Parameters ---------- x : np.ndarray [shape=(N, M)] Input matrix, will be modified in place. radius : float The band radius (1/2 of the width) will be ``int(radius*min(x.shape))`` value : float ``x[n, m] = value`` when ``(n, m)`` lies outside the band. Examples -------- >>> x = np.ones((8, 8)) >>> librosa.util.fill_off_diagonal(x, radius=0.25) >>> x array([[1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0], [0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 1, 0], [0, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]) >>> x = np.ones((8, 12)) >>> librosa.util.fill_off_diagonal(x, radius=0.25) >>> x array([[1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]]) rr)kN)rGr?rHroundrrtriu_indices_fromtril_indices_from)r<r6rnxnyoffsetidx_uidx_ls rUr+r+Gs`WFB&26!'??233 4 4F WFB VQWQZ!'!*, . .F Bww$Q&6/:::$Q6'222$Q&111$Q6'F*:;;;AeHAeHHHrV edge_orderr9rC Literal[1, 2]cdg|jz}||f||<tj||d}tj|||}t dg|jz}t || ||<|t |}|S)a.Estimate the gradient of a function over a uniformly sampled, periodic domain. This is essentially the same as `np.gradient`, except that edge effects are handled by wrapping the observations (i.e. assuming periodicity) rather than extrapolation. Parameters ---------- data : np.ndarray The function values observed at uniformly spaced positions on a periodic domain edge_order : {1, 2} The order of the difference approximation used for estimating the gradient axis : int The axis along which gradients are calculated. Returns ------- grad : np.ndarray like ``data`` The gradient of ``data`` taken along the specified axis. See Also -------- numpy.gradient Examples -------- This example estimates the gradient of cosine (-sine) from 64 samples using direct (aperiodic) and periodic gradient calculation. >>> import matplotlib.pyplot as plt >>> x = 2 * np.pi * np.linspace(0, 1, num=64, endpoint=False) >>> y = np.cos(x) >>> grad = np.gradient(y) >>> cyclic_grad = librosa.util.cyclic_gradient(y) >>> true_grad = -np.sin(x) * 2 * np.pi / len(x) >>> fig, ax = plt.subplots() >>> ax.plot(x, true_grad, label='True gradient', linewidth=5, ... alpha=0.35) >>> ax.plot(x, cyclic_grad, label='cyclic_gradient') >>> ax.plot(x, grad, label='np.gradient', linestyle=':') >>> ax.legend() >>> # Zoom into the first part of the sequence >>> ax.set(xlim=[0, np.pi/16], ylim=[-0.025, 0.025]) rvwrap)rtrBN)rNrHrygradientrMrJ)rprCr9paddingdata_padgradrT grad_slices rUr1r1shh"G,GDMvdG&111H ;xJT B B BDDkk]TY &Fj[11F4L!%--0J rVfactorr9rMc|dkr|j}tj|}t|jdD]+}tj|dd|f||z|dd|f<,|dkr|j}|S)z2Numba-accelerated shear for dense (ndarray) arraysrrN)TrHrrangerGroll)r(rMr9X_shearrs rU __shear_denserSs qyy CmAG 171:  55!!!Q$!441  qyy) NrVscipy.sparse.spmatrixc|j}|dkr|j}|d}tj|tj|jdztj|j}tj |j |z|jd|j |dkr|j}| |S)zFast shearing for sparse matrices Shearing is performed using CSC array indices, and the result is converted back to whatever sparse format the data was originally provided in. rT)rDr)out) formatrOtocscrHrepeatarangerGdiffindptrrindicesasformat)r(rMr9rrRrQs rU__shear_sparser_s (C qyy Cgg4g  G 9Vbi a(8999277>;R;R S SDF7?T !7=#3IIII qyy)   C  rV_ArrayOrSparseMatrix)boundcdSrrr(rMr9s rUr)r)CrVcdSrrrcs rUr)r)s CrVctjt|tjst d|dt j|rt|||St|||S)aeShear a matrix by a given factor. The column ``X[:, n]`` will be displaced (rolled) by ``factor * n`` This is primarily useful for converting between lag and recurrence representations: shearing with ``factor=-1`` converts the main diagonal to a horizontal. Shearing with ``factor=1`` converts a horizontal to a diagonal. Parameters ---------- X : np.ndarray [ndim=2] or scipy.sparse matrix The array to be sheared factor : integer The shear factor: ``X[:, n] -> np.roll(X[:, n], factor * n)`` axis : integer The axis along which to shear Returns ------- X_shear : same type as ``X`` The sheared matrix Examples -------- >>> E = np.eye(3) >>> librosa.util.shear(E, factor=-1, axis=-1) array([[1., 1., 1.], [0., 0., 0.], [0., 0., 0.]]) >>> librosa.util.shear(E, factor=-1, axis=0) array([[1., 0., 0.], [1., 0., 0.], [1., 0., 0.]]) >>> librosa.util.shear(E, factor=1, axis=-1) array([[1., 0., 0.], [0., 0., 1.], [0., 1., 0.]]) zfactor=z must be integer-valuedrL) rHr]rrjrrr isspmatrixr_rSrcs rUr)r)sV =frz 2 2HFvFFFGGG |q!!:aT::::QvD9999rVarraysList[np.ndarray]cd|D}t|dkrtdt|dkrtd|}|dkrtj||St t|gt |z}tj|}tj||d}tj||| |S) a+Stack one or more arrays along a target axis. This function is similar to `np.stack`, except that memory contiguity is retained when stacking along the first dimension. This is useful when combining multiple monophonic audio signals into a multi-channel signal, or when stacking multiple feature representations to form a multi-dimensional array. Parameters ---------- arrays : list one or more `np.ndarray` axis : integer The target axis along which to stack. ``axis=0`` creates a new first axis, and ``axis=-1`` creates a new last axis. Returns ------- arr_stack : np.ndarray [shape=(len(arrays), array_shape) or shape=(array_shape, len(arrays))] The input arrays, stacked along the target dimension. If ``axis=0``, then ``arr_stack`` will be F-contiguous. Otherwise, ``arr_stack`` will be C-contiguous by default, as computed by `np.stack`. Raises ------ ParameterError - If ``arrays`` do not all have the same shape - If no ``arrays`` are given See Also -------- numpy.stack numpy.ndarray.flags frame Examples -------- Combine two buffers into a contiguous arrays >>> y_left = np.ones(5) >>> y_right = -np.ones(5) >>> y_stereo = librosa.util.stack([y_left, y_right], axis=0) >>> y_stereo array([[ 1., 1., 1., 1., 1.], [-1., -1., -1., -1., -1.]]) >>> y_stereo.flags C_CONTIGUOUS : False F_CONTIGUOUS : True OWNDATA : True WRITEABLE : True ALIGNED : True WRITEBACKIFCOPY : False UPDATEIFCOPY : False Or along the trailing axis >>> y_stereo = librosa.util.stack([y_left, y_right], axis=-1) >>> y_stereo array([[ 1., -1.], [ 1., -1.], [ 1., -1.], [ 1., -1.], [ 1., -1.]]) >>> y_stereo.flags C_CONTIGUOUS : True F_CONTIGUOUS : False OWNDATA : True WRITEABLE : True ALIGNED : True WRITEBACKIFCOPY : False UPDATEIFCOPY : False ch|] }|j Sr)rG)rarrs rU zstack..s * * *Cci * * *rVrz)all input arrays must have the same shapez3at least one input array must be provided for stackrror)r^r)r9rV) rrpoprHr*rJrK result_typer)rhr9shapesshape_inrGr^results rUr*r*DsX+ *6 * * *F 6{{QHIII VqRSSSzz||H qyyxT****s6{{md8nn455'%uC888 d//// rV)defaultrErsOptional[type]ctjtjtjtjtjtjtjt tjtji}tj|}|j dkr|Stj| ||S)aFind the complex numpy dtype corresponding to a real dtype. This is used to maintain numerical precision and memory footprint when constructing complex arrays from real-valued data (e.g. in a Fourier transform). A `float32` (single-precision) type maps to `complex64`, while a `float64` (double-precision) maps to `complex128`. Parameters ---------- d : np.dtype The real-valued dtype to convert to complex. If ``d`` is a complex type already, it will be returned. default : np.dtype, optional The default complex target type, if ``d`` does not match a known dtype Returns ------- d_c : np.dtype The complex dtype See Also -------- dtype_c2r numpy.dtype Examples -------- >>> librosa.util.dtype_r2c(np.float32) dtype('complex64') >>> librosa.util.dtype_r2c(np.int16) dtype('complex64') >>> librosa.util.dtype_r2c(np.complex128) dtype('complex128') c) rHr^r+ complex64float64 complex128rdcomplexrkindgetrErsmappingdts rUr2r2sR bl bm '**/&G !B w#~~  8GKKG,, - --rVctjtjtjtjtjtjtjt tjtji}tj|}|j dkr|Stj| ||S)a(Find the real numpy dtype corresponding to a complex dtype. This is used to maintain numerical precision and memory footprint when constructing real arrays from complex-valued data (e.g. in an inverse Fourier transform). A `complex64` (single-precision) type maps to `float32`, while a `complex128` (double-precision) maps to `float64`. Parameters ---------- d : np.dtype The complex-valued dtype to convert to real. If ``d`` is a real (float) type already, it will be returned. default : np.dtype, optional The default real target type, if ``d`` does not match a known dtype Returns ------- d_r : np.dtype The real dtype See Also -------- dtype_r2c numpy.dtype Examples -------- >>> librosa.util.dtype_r2c(np.complex64) dtype('float32') >>> librosa.util.dtype_r2c(np.float32) dtype('float32') >>> librosa.util.dtype_r2c(np.int16) dtype('float32') >>> librosa.util.dtype_r2c(np.complex128) dtype('float64') f) rHr^rwr+ryrxrzrdrr{r|r}s rUr3r3sX    28E??/&G !B w#~~  8GKKG,, - --rVcDtj|}|jdS)zCount the number of unique values in an array. This function is a helper for `count_unique` and is not to be called directly. r)rHrrGr<uniquess rU__count_uniquer sillG = rVc8tjt||S)aCount the number of unique values in a multi-dimensional array along a given axis. Parameters ---------- data : np.ndarray The input array axis : int The target axis to count Returns ------- n_uniques The number of unique values. This array will have one fewer dimension than the input. See Also -------- is_unique Examples -------- >>> x = np.vander(np.arange(5)) >>> x array([[ 0, 0, 0, 0, 1], [ 1, 1, 1, 1, 1], [ 16, 8, 4, 2, 1], [ 81, 27, 9, 3, 1], [256, 64, 16, 4, 1]]) >>> # Count unique values along rows (within columns) >>> librosa.util.count_unique(x, axis=0) array([5, 5, 5, 5, 1]) >>> # Count unique values along columns (within rows) >>> librosa.util.count_unique(x, axis=-1) array([2, 1, 5, 5, 5]) )rHapply_along_axisrrpr9s rUr4r4( sJ  ~tT : ::rVcVtj|}|jd|jkS)zDetermine if the input array has all unique values. This function is a helper for `is_unique` and is not to be called directly. r)rHrrGrqrs rU __is_uniquerP s%illG = qv %%rVc8tjt||S)aDetermine if the input array consists of all unique values along a given axis. Parameters ---------- data : np.ndarray The input array axis : int The target axis Returns ------- is_unique Array of booleans indicating whether the data is unique along the chosen axis. This array will have one fewer dimension than the input. See Also -------- count_unique Examples -------- >>> x = np.vander(np.arange(5)) >>> x array([[ 0, 0, 0, 0, 1], [ 1, 1, 1, 1, 1], [ 16, 8, 4, 2, 1], [ 81, 27, 9, 3, 1], [256, 64, 16, 4, 1]]) >>> # Check uniqueness along rows >>> librosa.util.is_unique(x, axis=0) array([ True, True, True, True, False]) >>> # Check uniqueness along columns >>> librosa.util.is_unique(x, axis=-1) array([False, False, True, True, True]) )rHrrrs rUr5r5[ sL  {D$ 7 77rVzfloat32(complex64)zfloat64(complex128))rridentityrc,|jdz|jdzzS)z*Efficiently compute abs2 on complex inputsr)realimagrks rU_cabs2r s 619qvqy  rVznp.number[Any]_NumberOrArrayctj|r(t|}||S||Stj||S)aCompute the squared magnitude of a real or complex array. This function is equivalent to calling `np.abs(x)**2` but it is slightly more efficient. Parameters ---------- x : np.ndarray or scalar, real or complex typed The input data, either real (float32, float64) or complex (complex64, complex128) typed dtype : np.dtype, optional The data type of the output array. If not provided, it will be inferred from `x` Returns ------- p : np.ndarray or scale, real squared magnitude of `x` Examples -------- >>> librosa.util.abs2(3 + 4j) 25.0 >>> librosa.util.abs2((0.5j)**np.arange(8)) array([1.000e+00, 2.500e-01, 6.250e-02, 1.562e-02, 3.906e-03, 9.766e-04, 2.441e-04, 6.104e-05]) Nr)rH iscomplexobjrrsquare)r<r^rYs rUr6r6 sR8 q ) 1II =H88E?? "y%((((rVzcomplex64(float32)zcomplex128(float64)np.complexfloating[Any, Any]cZtj|dtj|zzS)Ny?)rHcossinrks rU_phasor_anglesr s# 6!99rBF1II~ %%rVznp.integer[Any]znp.floating[Any])ranglesrOptional[np.ndarray]cdSrrrrs rUr7r7 rdrV_RealOptional[_Number]cdSrrrs rUr7r7 rdrVUnion[np.ndarray, _Real]$Optional[Union[np.ndarray, _Number]]/Union[np.ndarray, np.complexfloating[Any, Any]]c2t|}|||z}|S)aConstruct a complex phasor representation from angles. When `mag` is not provided, this is equivalent to: z = np.cos(angles) + 1j * np.sin(angles) or by Euler's formula: z = np.exp(1j * angles) When `mag` is provided, this is equivalent to: z = mag * np.exp(1j * angles) This function should be more efficient (in time and memory) than the equivalent' formulations above, but produce numerically identical results. Parameters ---------- angles : np.ndarray or scalar, real-valued Angle(s), measured in radians mag : np.ndarray or scalar, optional If provided, phasor(s) will be scaled by `mag`. If not provided (default), phasors will have unit magnitude. `mag` must be of compatible shape to multiply with `angles`. Returns ------- z : np.ndarray or scalar, complex-valued Complex number(s) z corresponding to the given angle(s) and optional magnitude(s). Examples -------- Construct unit phasors at angles 0, pi/2, and pi: >>> librosa.util.phasor([0, np.pi/2, np.pi]) array([ 1.000e+00+0.000e+00j, 6.123e-17+1.000e+00j, -1.000e+00+1.225e-16j]) Construct a phasor with magnitude 1/2: >>> librosa.util.phasor(np.pi/2, mag=0.5) (3.061616997868383e-17+0.5j) Or arrays of angles and magnitudes: >>> librosa.util.phasor(np.array([0, np.pi/2]), mag=np.array([0.5, 1.5])) array([5.000e-01+0.j , 9.185e-17+1.5j]) )r)rrzs rUr7r7 s%t vA  S HrV)r<r=r>r?r@r?r9r?r:rAr;rArBr=)rYr=rBrA)r<rdrcrerBr?)r<rdrBrA)rlr=rBrA) rpr=rqr?r9r?rrr rBr=)r<r=rNr?r}r~rBr=) rrrrrrryrArBr=) rr=r9r?rrrrrBr=) rr=r9r?rrrrrBr) rr=r9r?rrArrrBr) rr=rrr9rrrrrrBr=)r<r=r9r?rBr=)r<r=rr?rr?rr?rr?rrdrr?rrAr9r?rBr=)r<r=rrdr^rrBr)r<r=rr?r^r rBr=) rrr rr rr rryrArBr ) rpr=rrrrryrAr9r?rBr=) r(r=r)r=r&rdr'rArBr=)r<r3rBr)r<r=r6rdrrdrBr7)rpr=rCrDr9r?rBr=)r(r=rMr?r9r?rBr=)r(rTrMr?r9r?rBrT)r(r`rMr?r9r?rBr`)rhrir9r?rBr=)rEr rsrtrBr )rpr=r9r?rBr=)r<rrBrr)r<rr^rrBr)rBr)rr=rrrBr=)rrrrrBr)rrrrrBr)___doc__ __future__r scipy.ndimager scipy.sparsenumpyrHnumbanumpy.lib.stride_tricksr_cacher exceptionsr deprecationr numpy.typingr typingr r r rrrrrrrtyping_extensionsr_typingrrrr__all__rrrr r!rrrr"r#rr&stencilrr guvectorizerrr$r%rr'r(r+r/r,r-r.r0r+r1jitrSr_r\rspmatrixr`r)r*rwr2r3rr4rr5 vectorizerrz_Numberrr6rrdrr7rrVrUrs< """""" ......&&&&&&######""""""                        &%%%%%CCCCCCCCCC    PccccccLR>>>>BGK@ 8 8 8 8613G+G+G+G+G+G+TDDDDP13888888| VVVVVVr *-   *-  *. a$a$a$a$a$a$HRF)- ddddddN+++ +++                 ,-::::::z,-;;;;;;~ ! R{{{{{{|R(,4______F&'2:777777D"! 7W7W7W7W7W7WtR /3 ~~~~~~D9:ussssssl@ @ @ @ FGHAAAAAAJ67B??????D D%%%24"     &% "02r!!!!!!>w% EL4I(I"J  *-3  /2 /0R3:3:3:3:3:3:l45ccccccL:<5.5.5.5.5.5.p:<8.8.8.8.8.8.v D%%%&%35%;%;%;%;%;%;P D%%%&&&%&02&8&8&8&8&8&8R01DWX!!!! )) *)w 7J1KLLL%)%)%)%)%)P01DWX&&&& e&(::; >A  69 15? ? ? ? ? ? ? ? rV