@cache(level=<NUM_LIT:20>)<EOL>def pseudo_cqt(y, sr=<NUM_LIT>, hop_length=<NUM_LIT>, fmin=None, n_bins=<NUM_LIT>,<EOL>bins_per_octave=<NUM_LIT:12>, tuning=<NUM_LIT:0.0>, filter_scale=<NUM_LIT:1>,<EOL>norm=<NUM_LIT:1>, sparsity=<NUM_LIT>, window='<STR_LIT>', scale=True,<EOL>pad_mode='<STR_LIT>'):
if fmin is None:<EOL><INDENT>fmin = note_to_hz('<STR_LIT>')<EOL><DEDENT>if tuning is None:<EOL><INDENT>tuning = estimate_tuning(y=y, sr=sr)<EOL><DEDENT>fft_basis, n_fft, _ = __cqt_filter_fft(sr, fmin, n_bins,<EOL>bins_per_octave,<EOL>tuning, filter_scale,<EOL>norm, sparsity,<EOL>hop_length=hop_length,<EOL>window=window)<EOL>fft_basis = np.abs(fft_basis)<EOL>D = np.abs(stft(y, n_fft=n_fft, hop_length=hop_length, pad_mode=pad_mode))<EOL>C = fft_basis.dot(D)<EOL>if scale:<EOL><INDENT>C /= np.sqrt(n_fft)<EOL><DEDENT>else:<EOL><INDENT>lengths = filters.constant_q_lengths(sr, fmin,<EOL>n_bins=n_bins,<EOL>bins_per_octave=bins_per_octave,<EOL>tuning=tuning,<EOL>window=window,<EOL>filter_scale=filter_scale)<EOL>C *= np.sqrt(lengths[:, np.newaxis] / n_fft)<EOL><DEDENT>return C<EOL>
Compute the pseudo constant-Q transform of an audio signal.

    This uses a single fft size that is the smallest power of 2 that is greater
    than or equal to the max of:

        1. The longest CQT filter
        2. 2x the hop_length

    Parameters
    ----------
    y : np.ndarray [shape=(n,)]
        audio time series

    sr : number > 0 [scalar]
        sampling rate of `y`

    hop_length : int > 0 [scalar]
        number of samples between successive CQT columns.

    fmin : float > 0 [scalar]
        Minimum frequency. Defaults to C1 ~= 32.70 Hz

    n_bins : int > 0 [scalar]
        Number of frequency bins, starting at `fmin`

    bins_per_octave : int > 0 [scalar]
        Number of bins per octave

    tuning : None or float in `[-0.5, 0.5)`
        Tuning offset in fractions of a bin (cents).

        If `None`, tuning will be automatically estimated from the signal.

    filter_scale : float > 0
        Filter filter_scale factor. Larger values use longer windows.

    sparsity : float in [0, 1)
        Sparsify the CQT basis by discarding up to `sparsity`
        fraction of the energy in each basis.

        Set `sparsity=0` to disable sparsification.

    window : str, tuple, number, or function
        Window specification for the basis filters.
        See `filters.get_window` for details.

    pad_mode : string
        Padding mode for centered frame analysis.

        See also: `librosa.core.stft` and `np.pad`.

    Returns
    -------
    CQT : np.ndarray [shape=(n_bins, t), dtype=np.float]
        Pseudo Constant-Q energy for each frequency at each time.

    Raises
    ------
    ParameterError
        If `hop_length` is not an integer multiple of
        `2**(n_bins / bins_per_octave)`

        Or if `y` is too short to support the frequency range of the CQT.

    Notes
    -----
    This function caches at level 20.