Signal processing (`cupyx.scipy.signal`)#

Convolution#

 `convolve`(in1, in2[, mode, method]) Convolve two N-dimensional arrays. `correlate`(in1, in2[, mode, method]) Cross-correlate two N-dimensional arrays. `fftconvolve`(in1, in2[, mode, axes]) Convolve two N-dimensional arrays using FFT. `oaconvolve`(in1, in2[, mode, axes]) Convolve two N-dimensional arrays using the overlap-add method. `convolve2d`(in1, in2[, mode, boundary, fillvalue]) Convolve two 2-dimensional arrays. `correlate2d`(in1, in2[, mode, boundary, ...]) Cross-correlate two 2-dimensional arrays. `sepfir2d`(input, hrow, hcol) Convolve with a 2-D separable FIR filter. `choose_conv_method`(in1, in2[, mode]) Find the fastest convolution/correlation method. `correlation_lags`(in1_len, in2_len[, mode]) Calculates the lag / displacement indices array for 1D cross-correlation.

B-Splines#

 `gauss_spline`(x, n) Gaussian approximation to B-spline basis function of order n. `cspline1d`(signal[, lamb]) Compute cubic spline coefficients for rank-1 array. `qspline1d`(signal[, lamb]) Compute quadratic spline coefficients for rank-1 array. `cspline2d`(signal[, lamb, precision]) Coefficients for 2-D cubic (3rd order) B-spline. `qspline2d`(signal[, lamb, precision]) Coefficients for 2-D quadratic (2nd order) B-spline. `cspline1d_eval`(cj, newx[, dx, x0]) Evaluate a cubic spline at the new set of points. `qspline1d_eval`(cj, newx[, dx, x0]) Evaluate a quadratic spline at the new set of points. `spline_filter`(Iin[, lmbda]) Smoothing spline (cubic) filtering of a rank-2 array.

Filtering#

 `order_filter`(a, domain, rank) Perform an order filter on an N-D array. `medfilt`(volume[, kernel_size]) Perform a median filter on an N-dimensional array. `medfilt2d`(input[, kernel_size]) Median filter a 2-dimensional array. `wiener`(im[, mysize, noise]) Perform a Wiener filter on an N-dimensional array. `symiirorder1`(input, c0, z1[, precision]) Implement a smoothing IIR filter with mirror-symmetric boundary conditions using a cascade of first-order sections. The second section uses a reversed sequence. This implements a system with the following transfer function and mirror-symmetric boundary conditions::. `symiirorder2`(input, r, omega[, precision]) Implement a smoothing IIR filter with mirror-symmetric boundary conditions using a cascade of second-order sections. The second section uses a reversed sequence. This implements the following transfer function::. `lfilter`(b, a, x[, axis, zi]) Filter data along one-dimension with an IIR or FIR filter. `lfiltic`(b, a, y[, x]) Construct initial conditions for lfilter given input and output vectors. `lfilter_zi`(b, a) Construct initial conditions for lfilter for step response steady-state. `filtfilt`(b, a, x[, axis, padtype, padlen, ...]) Apply a digital filter forward and backward to a signal. `savgol_filter`(x, window_length, polyorder[, ...]) Apply a Savitzky-Golay filter to an array. `deconvolve`(signal, divisor) Deconvolves `divisor` out of `signal` using inverse filtering. `sosfilt`(sos, x[, axis, zi]) Filter data along one dimension using cascaded second-order sections. `sosfilt_zi`(sos) Construct initial conditions for sosfilt for step response steady-state. `sosfiltfilt`(sos, x[, axis, padtype, padlen]) A forward-backward digital filter using cascaded second-order sections. `hilbert`(x[, N, axis]) Compute the analytic signal, using the Hilbert transform. `hilbert2`(x[, N]) Compute the '2-D' analytic signal of x `decimate`(x, q[, n, ftype, axis, zero_phase]) Downsample the signal after applying an anti-aliasing filter. `detrend`(data[, axis, type, bp, overwrite_data]) Remove linear trend along axis from data. `resample`(x, num[, t, axis, window, domain]) Resample x to num samples using Fourier method along the given axis. `resample_poly`(x, up, down[, axis, window, ...]) Resample x along the given axis using polyphase filtering. `upfirdn`(h, x[, up, down, axis, mode, cval]) Upsample, FIR filter, and downsample.

Filter design#

 `bilinear`(b, a[, fs]) Return a digital IIR filter from an analog one using a bilinear transform. `bilinear_zpk`(z, p, k, fs) Return a digital IIR filter from an analog one using a bilinear transform. `findfreqs`(num, den, N[, kind]) Find array of frequencies for computing the response of an analog filter. `freqs`(b, a[, worN, plot]) Compute frequency response of analog filter. `freqs_zpk`(z, p, k[, worN]) Compute frequency response of analog filter. `freqz`(b[, a, worN, whole, plot, fs, ...]) Compute the frequency response of a digital filter. `freqz_zpk`(z, p, k[, worN, whole, fs]) Compute the frequency response of a digital filter in ZPK form. `sosfreqz`(sos[, worN, whole, fs]) Compute the frequency response of a digital filter in SOS format. `firwin`(numtaps, cutoff[, width, window, ...]) FIR filter design using the window method. `firwin2`(numtaps, freq, gain[, nfreqs, ...]) FIR filter design using the window method. `firls`(numtaps, bands, desired[, weight, fs]) FIR filter design using least-squares error minimization. `minimum_phase`(h[, method, n_fft]) Convert a linear-phase FIR filter to minimum phase `savgol_coeffs`(window_length, polyorder[, ...]) Compute the coefficients for a 1-D Savitzky-Golay FIR filter. `gammatone`(freq, ftype[, order, numtaps, fs]) Gammatone filter design. `group_delay`(system[, w, whole, fs]) Compute the group delay of a digital filter. `iirdesign`(wp, ws, gpass, gstop[, analog, ...]) Complete IIR digital and analog filter design. `iirfilter`(N, Wn[, rp, rs, btype, analog, ...]) IIR digital and analog filter design given order and critical points. `kaiser_atten`(numtaps, width) Compute the attenuation of a Kaiser FIR filter. Compute the Kaiser parameter beta, given the attenuation a. `kaiserord`(ripple, width) Determine the filter window parameters for the Kaiser window method. `unique_roots`(p[, tol, rtype]) Determine unique roots and their multiplicities from a list of roots. `residue`(b, a[, tol, rtype]) Compute partial-fraction expansion of b(s) / a(s). `residuez`(b, a[, tol, rtype]) Compute partial-fraction expansion of b(z) / a(z). `invres`(r, p, k[, tol, rtype]) Compute b(s) and a(s) from partial fraction expansion. `invresz`(r, p, k[, tol, rtype]) Compute b(z) and a(z) from partial fraction expansion. `BadCoefficients` Warning about badly conditioned filter coefficients

Matlab-style IIR filter design#

 `butter`(N, Wn[, btype, analog, output, fs]) Butterworth digital and analog filter design. `buttord`(wp, ws, gpass, gstop[, analog, fs]) Butterworth filter order selection. `ellip`(N, rp, rs, Wn[, btype, analog, output, fs]) Elliptic (Cauer) digital and analog filter design. `ellipord`(wp, ws, gpass, gstop[, analog, fs]) Elliptic (Cauer) filter order selection. `cheby1`(N, rp, Wn[, btype, analog, output, fs]) Chebyshev type I digital and analog filter design. `cheb1ord`(wp, ws, gpass, gstop[, analog, fs]) Chebyshev type I filter order selection. `cheby2`(N, rs, Wn[, btype, analog, output, fs]) Chebyshev type II digital and analog filter design. `cheb2ord`(wp, ws, gpass, gstop[, analog, fs]) Chebyshev type II filter order selection. `iircomb`(w0, Q[, ftype, fs, pass_zero]) Design IIR notching or peaking digital comb filter. `iirnotch`(w0, Q[, fs]) Design second-order IIR notch digital filter. `iirpeak`(w0, Q[, fs]) Design second-order IIR peak (resonant) digital filter.

Low-level filter design functions#

 `abcd_normalize`([A, B, C, D]) Check state-space matrices and ensure they are 2-D. `band_stop_obj`(wp, ind, passb, stopb, gpass, ...) Band Stop Objective Function for order minimization. Return (z,p,k) for analog prototype of Nth-order Butterworth filter. `cheb1ap`(N, rp) Return (z,p,k) for Nth-order Chebyshev type I analog lowpass filter. `cheb2ap`(N, rs) Return (z,p,k) for Nth-order Chebyshev type I analog lowpass filter. `ellipap`(N, rp, rs) Return (z,p,k) of Nth-order elliptic analog lowpass filter. `lp2bp`(b, a[, wo, bw]) Transform a lowpass filter prototype to a bandpass filter. `lp2bp_zpk`(z, p, k[, wo, bw]) Transform a lowpass filter prototype to a bandpass filter. `lp2bs`(b, a[, wo, bw]) Transform a lowpass filter prototype to a bandstop filter. `lp2bs_zpk`(z, p, k[, wo, bw]) Transform a lowpass filter prototype to a bandstop filter. `lp2hp`(b, a[, wo]) Transform a lowpass filter prototype to a highpass filter. `lp2hp_zpk`(z, p, k[, wo]) Transform a lowpass filter prototype to a highpass filter. `lp2lp`(b, a[, wo]) Transform a lowpass filter prototype to a different frequency. `lp2lp_zpk`(z, p, k[, wo]) Transform a lowpass filter prototype to a different frequency. `normalize`(b, a) Normalize numerator/denominator of a continuous-time transfer function.

LTI representations#

 `zpk2tf`(z, p, k) Return polynomial transfer function representation from zeros and poles `zpk2sos`(z, p, k[, pairing, analog]) Return second-order sections from zeros, poles, and gain of a system `zpk2ss`(z, p, k) Zero-pole-gain representation to state-space representation `tf2zpk`(b, a) Return zero, pole, gain (z, p, k) representation from a numerator, denominator representation of a linear filter. `tf2sos`(b, a[, pairing, analog]) Return second-order sections from transfer function representation `tf2ss`(num, den) Transfer function to state-space representation. `ss2tf`(A, B, C, D[, input]) State-space to transfer function. `ss2zpk`(A, B, C, D[, input]) State-space representation to zero-pole-gain representation. `sos2tf`(sos) Return a single transfer function from a series of second-order sections `sos2zpk`(sos) Return zeros, poles, and gain of a series of second-order sections `cont2discrete`(system, dt[, method, alpha]) Transform a continuous to a discrete state-space system. `place_poles`(A, B, poles[, method, rtol, maxiter]) Compute K such that eigenvalues (A - dot(B, K))=poles.

Continuous-time linear systems#

 `lti`(*system) Continuous-time linear time invariant system base class. `StateSpace`(*system, **kwargs) Linear Time Invariant system in state-space form. `TransferFunction`(*system, **kwargs) Linear Time Invariant system class in transfer function form. `ZerosPolesGain`(*system, **kwargs) Linear Time Invariant system class in zeros, poles, gain form. `lsim`(system, U, T[, X0, interp]) Simulate output of a continuous-time linear system. `impulse`(system[, X0, T, N]) Impulse response of continuous-time system. `step`(system[, X0, T, N]) Step response of continuous-time system. `freqresp`(system[, w, n]) Calculate the frequency response of a continuous-time system. `bode`(system[, w, n]) Calculate Bode magnitude and phase data of a continuous-time system.

Discrete-time linear systems#

 `dlti`(*system, **kwargs) Discrete-time linear time invariant system base class. `StateSpace`(*system, **kwargs) Linear Time Invariant system in state-space form. `TransferFunction`(*system, **kwargs) Linear Time Invariant system class in transfer function form. `ZerosPolesGain`(*system, **kwargs) Linear Time Invariant system class in zeros, poles, gain form. `dlsim`(system, u[, t, x0]) Simulate output of a discrete-time linear system. `dimpulse`(system[, x0, t, n]) Impulse response of discrete-time system. `dstep`(system[, x0, t, n]) Step response of discrete-time system. `dfreqresp`(system[, w, n, whole]) Calculate the frequency response of a discrete-time system. `dbode`(system[, w, n]) Calculate Bode magnitude and phase data of a discrete-time system.

Waveforms#

 `chirp`(t, f0, t1, f1[, method, phi, vertex_zero]) Frequency-swept cosine generator. `gausspulse`(t[, fc, bw, bwr, tpr, retquad, ...]) Return a Gaussian modulated sinusoid: `max_len_seq`(nbits[, state, length, taps]) Maximum length sequence (MLS) generator. `sawtooth`(t[, width]) Return a periodic sawtooth or triangle waveform. `square`(t[, duty]) Return a periodic square-wave waveform. `unit_impulse`(shape[, idx, dtype]) Unit impulse signal (discrete delta function) or unit basis vector. `sweep_poly`(t, poly[, phi]) Frequency-swept cosine generator, with a time-dependent frequency.

Window functions#

For window functions, see the `cupyx.scipy.signal.windows` namespace.

In the `cupyx.scipy.signal` namespace, there is a convenience function to obtain these windows by name:

 `get_window`(window, Nx[, fftbins]) Return a window of a given length and type.

Wavelets#

 `morlet`(M[, w, s, complete]) Complex Morlet wavelet. `qmf`(hk) Return high-pass qmf filter from low-pass `ricker`(points, a) Return a Ricker wavelet, also known as the "Mexican hat wavelet". `morlet2`(M, s[, w]) Complex Morlet wavelet, designed to work with cwt. Returns the complete version of morlet wavelet, normalised according to s::. `cwt`(data, wavelet, widths) Continuous wavelet transform.

Peak finding#

 `argrelmin`(data[, axis, order, mode]) Calculate the relative minima of data. `argrelmax`(data[, axis, order, mode]) Calculate the relative maxima of data. `argrelextrema`(data, comparator[, axis, ...]) Calculate the relative extrema of data. `find_peaks`(x[, height, threshold, distance, ...]) Find peaks inside a signal based on peak properties. `peak_prominences`(x, peaks[, wlen]) Calculate the prominence of each peak in a signal. `peak_widths`(x, peaks[, rel_height, ...]) Calculate the width of each peak in a signal.

Spectral analysis#

 `periodogram`(x[, fs, window, nfft, detrend, ...]) Estimate power spectral density using a periodogram. `welch`(x[, fs, window, nperseg, noverlap, ...]) Estimate power spectral density using Welch's method. `csd`(x, y[, fs, window, nperseg, noverlap, ...]) Estimate the cross power spectral density, Pxy, using Welch's method. `coherence`(x, y[, fs, window, nperseg, ...]) Estimate the magnitude squared coherence estimate, Cxy, of discrete-time signals X and Y using Welch's method. `spectrogram`(x[, fs, window, nperseg, ...]) Compute a spectrogram with consecutive Fourier transforms. `lombscargle`(x, y, freqs) Computes the Lomb-Scargle periodogram. `vectorstrength`(events, period) Determine the vector strength of the events corresponding to the given period. `stft`(x[, fs, window, nperseg, noverlap, ...]) Compute the Short Time Fourier Transform (STFT). `istft`(Zxx[, fs, window, nperseg, noverlap, ...]) Perform the inverse Short Time Fourier transform (iSTFT). `check_COLA`(window, nperseg, noverlap[, tol]) Check whether the Constant OverLap Add (COLA) constraint is met. `check_NOLA`(window, nperseg, noverlap[, tol]) Check whether the Nonzero Overlap Add (NOLA) constraint is met.

Chirp Z-transform and Zoom FFT#

 `czt`(x[, m, w, a, axis]) Compute the frequency response around a spiral in the Z plane. `zoom_fft`(x, fn[, m, fs, endpoint, axis]) Compute the DFT of x only for frequencies in range fn. `CZT`(n[, m, w, a]) Create a callable chirp z-transform function. `ZoomFFT`(n, fn[, m, fs, endpoint]) Create a callable zoom FFT transform function. `czt_points`(m[, w, a]) Return the points at which the chirp z-transform is computed.