| abcd_normalize(A=None, B=None, C=None, D=None) |
Check state-space matrices and ensure they are 2-D. [extrait de abcd_normalize.__doc__] |
| argrelextrema(data, comparator, axis=0, order=1, mode='clip') |
|
| argrelmax(data, axis=0, order=1, mode='clip') |
|
| argrelmin(data, axis=0, order=1, mode='clip') |
|
| band_stop_obj(wp, ind, passb, stopb, gpass, gstop, type) |
|
| bessel(N, Wn, btype='low', analog=False, output='ba', norm='phase', fs=None) |
|
| besselap(N, norm='phase') |
|
| bilinear(b, a, fs=1.0) |
|
| bilinear_zpk(z, p, k, fs) |
|
| bode(system, w=None, n=100) |
|
| buttap(N) |
Return (z,p,k) for analog prototype of Nth-order Butterworth filter. [extrait de buttap.__doc__] |
| butter(N, Wn, btype='low', analog=False, output='ba', fs=None) |
|
| buttord(wp, ws, gpass, gstop, analog=False, fs=None) |
Butterworth filter order selection. [extrait de buttord.__doc__] |
| cheb1ap(N, rp) |
|
| cheb1ord(wp, ws, gpass, gstop, analog=False, fs=None) |
Chebyshev type I filter order selection. [extrait de cheb1ord.__doc__] |
| cheb2ap(N, rs) |
|
| cheb2ord(wp, ws, gpass, gstop, analog=False, fs=None) |
Chebyshev type II filter order selection. [extrait de cheb2ord.__doc__] |
| cheby1(N, rp, Wn, btype='low', analog=False, output='ba', fs=None) |
|
| cheby2(N, rs, Wn, btype='low', analog=False, output='ba', fs=None) |
|
| check_COLA(window, nperseg, noverlap, tol=1e-10) |
Check whether the Constant OverLap Add (COLA) constraint is met. [extrait de check_COLA.__doc__] |
| check_NOLA(window, nperseg, noverlap, tol=1e-10) |
Check whether the Nonzero Overlap Add (NOLA) constraint is met. [extrait de check_NOLA.__doc__] |
| chirp(t, f0, t1, f1, method='linear', phi=0, vertex_zero=True, *, complex=False) |
Frequency-swept cosine generator. [extrait de chirp.__doc__] |
| choose_conv_method(in1, in2, mode='full', measure=False) |
|
| coherence(x, y, fs=1.0, window='hann', nperseg=None, noverlap=None, nfft=None, detrend='constant', axis=-1) |
|
| cont2discrete(system, dt, method='zoh', alpha=None) |
|
| convolve(in1, in2, mode='full', method='auto') |
|
| convolve2d(in1, in2, mode='full', boundary='fill', fillvalue=0) |
|
| correlate(in1, in2, mode='full', method='auto') |
|
| correlate2d(in1, in2, mode='full', boundary='fill', fillvalue=0) |
|
| correlation_lags(in1_len, in2_len, mode='full') |
|
| csd(x, y, fs=1.0, window='hann', nperseg=None, noverlap=None, nfft=None, detrend='constant', return_onesided=True, scaling='density', axis=-1, average='mean') |
|
| cspline1d(signal, lamb=0.0) |
|
| cspline1d_eval(cj, newx, dx=1.0, x0=0) |
Evaluate a cubic spline at the new set of points. [extrait de cspline1d_eval.__doc__] |
| cspline2d(signal, lamb=0.0, precision=-1.0) |
|
| czt(x, m=None, w=None, a=(1+0j), *, axis=-1) |
|
| czt_points(m, w=None, a=(1+0j)) |
|
| dbode(system, w=None, n=100) |
|
| decimate(x, q, n=None, ftype='iir', axis=-1, zero_phase=True) |
|
| deconvolve(signal, divisor) |
Deconvolves ``divisor`` out of ``signal`` using inverse filtering. [extrait de deconvolve.__doc__] |
| detrend(data: 'np.ndarray', axis: 'int' = -1, type: "Literal['linear', 'constant']" = 'linear', bp: 'ArrayLike | int' = 0, overwrite_data: 'bool' = False) -> 'np.ndarray' |
Remove linear or constant trend along axis from data. [extrait de detrend.__doc__] |
| dfreqresp(system, w=None, n=10000, whole=False) |
|
| dimpulse(system, x0=None, t=None, n=None) |
|
| dlsim(system, u, t=None, x0=None) |
|
| dstep(system, x0=None, t=None, n=None) |
|
| ellip(N, rp, rs, Wn, btype='low', analog=False, output='ba', fs=None) |
|
| ellipap(N, rp, rs) |
Return (z,p,k) of Nth-order elliptic analog lowpass filter. [extrait de ellipap.__doc__] |
| ellipord(wp, ws, gpass, gstop, analog=False, fs=None) |
Elliptic (Cauer) filter order selection. [extrait de ellipord.__doc__] |
| envelope(z: 'np.ndarray', bp_in: 'tuple[int | None, int | None]' = (1, None), *, n_out: 'int | None' = None, squared: 'bool' = False, residual: "Literal['lowpass', 'all', None]" = 'lowpass', axis: 'int' = -1) -> 'np.ndarray' |
Compute the envelope of a real- or complex-valued signal. [extrait de envelope.__doc__] |
| fftconvolve(in1, in2, mode='full', axes=None) |
Convolve two N-dimensional arrays using FFT. [extrait de fftconvolve.__doc__] |
| filtfilt(b, a, x, axis=-1, padtype='odd', padlen=None, method='pad', irlen=None) |
|
| find_peaks(x, height=None, threshold=None, distance=None, prominence=None, width=None, wlen=None, rel_height=0.5, plateau_size=None) |
|
| find_peaks_cwt(vector, widths, wavelet=None, max_distances=None, gap_thresh=None, min_length=None, min_snr=1, noise_perc=10, window_size=None) |
|
| findfreqs(num, den, N, kind='ba') |
|
| firls(numtaps, bands, desired, *, weight=None, fs=None) |
|
| firwin(numtaps, cutoff, *, width=None, window='hamming', pass_zero=True, scale=True, fs=None) |
|
| firwin2(numtaps, freq, gain, *, nfreqs=None, window='hamming', antisymmetric=False, fs=None) |
|
| freqresp(system, w=None, n=10000) |
Calculate the frequency response of a continuous-time system. [extrait de freqresp.__doc__] |
| freqs(b, a, worN=200, plot=None) |
|
| freqs_zpk(z, p, k, worN=200) |
|
| freqz(b, a=1, worN=512, whole=False, plot=None, fs=6.283185307179586, include_nyquist=False) |
|
| freqz_sos(sos, worN=512, whole=False, fs=6.283185307179586) |
|
| freqz_zpk(z, p, k, worN=512, whole=False, fs=6.283185307179586) |
|
| gammatone(freq, ftype, order=None, numtaps=None, fs=None) |
|
| gauss_spline(x, n) |
Gaussian approximation to B-spline basis function of order n. [extrait de gauss_spline.__doc__] |
| gausspulse(t, fc=1000, bw=0.5, bwr=-6, tpr=-60, retquad=False, retenv=False) |
|
| get_window(window, Nx, fftbins=True) |
|
| group_delay(system, w=512, whole=False, fs=6.283185307179586) |
Compute the group delay of a digital filter. [extrait de group_delay.__doc__] |
| hilbert(x, N=None, axis=-1) |
FFT-based computation of the analytic signal. [extrait de hilbert.__doc__] |
| hilbert2(x, N=None) |
|
| iircomb(w0, Q, ftype='notch', fs=2.0, *, pass_zero=False) |
|
| iirdesign(wp, ws, gpass, gstop, analog=False, ftype='ellip', output='ba', fs=None) |
Complete IIR digital and analog filter design. [extrait de iirdesign.__doc__] |
| iirfilter(N, Wn, rp=None, rs=None, btype='band', analog=False, ftype='butter', output='ba', fs=None) |
|
| iirnotch(w0, Q, fs=2.0) |
|
| iirpeak(w0, Q, fs=2.0) |
|
| impulse(system, X0=None, T=None, N=None) |
Impulse response of continuous-time system. [extrait de impulse.__doc__] |
| invres(r, p, k, tol=0.001, rtype='avg') |
Compute b(s) and a(s) from partial fraction expansion. [extrait de invres.__doc__] |
| invresz(r, p, k, tol=0.001, rtype='avg') |
Compute b(z) and a(z) from partial fraction expansion. [extrait de invresz.__doc__] |
| istft(Zxx, fs=1.0, window='hann', nperseg=None, noverlap=None, nfft=None, input_onesided=True, boundary=True, time_axis=-1, freq_axis=-2, scaling='spectrum') |
Perform the inverse Short Time Fourier transform (legacy function). [extrait de istft.__doc__] |
| kaiser_atten(numtaps, width) |
Compute the attenuation of a Kaiser FIR filter. [extrait de kaiser_atten.__doc__] |
| kaiser_beta(a) |
Compute the Kaiser parameter `beta`, given the attenuation `a`. [extrait de kaiser_beta.__doc__] |
| kaiserord(ripple, width) |
|
| lfilter(b, a, x, axis=-1, zi=None) |
|
| lfilter_zi(b, a) |
|
| lfiltic(b, a, y, x=None) |
|
| lombscargle(x: Union[collections.abc.Buffer, numpy._typing._array_like._SupportsArray[numpy.dtype[Any]], numpy._typing._nested_sequence._NestedSequence[numpy._typing._array_like._SupportsArray[numpy.dtype[Any]]], bool, int, float, complex, str, bytes, numpy._typing._nested_sequence._NestedSequence[bool | int | float | complex | str | bytes]], y: Union[collections.abc.Buffer, numpy._typing._array_like._SupportsArray[numpy.dtype[Any]], numpy._typing._nested_sequence._NestedSequence[numpy._typing._array_like._SupportsArray[numpy.dtype[Any]]], bool, int, float, complex, str, bytes, numpy._typing._nested_sequence._NestedSequence[bool | int | float | complex | str | bytes]], freqs: Union[collections.abc.Buffer, numpy._typing._array_like._SupportsArray[numpy.dtype[Any]], numpy._typing._nested_sequence._NestedSequence[numpy._typing._array_like._SupportsArray[numpy.dtype[Any]]], bool, int, float, complex, str, bytes, numpy._typing._nested_sequence._NestedSequence[bool | int | float | complex | str | bytes]], precenter: bool = False, normalize: Union[bool, Literal['power', 'normalize', 'amplitude']] = False, *, weights: numpy.ndarray[tuple[int, ...], numpy.dtype[+_ScalarType_co]] | None = None, floating_mean: bool = False) -> numpy.ndarray[tuple[int, ...], numpy.dtype[+_ScalarType_co]] |
|
| lp2bp(b, a, wo=1.0, bw=1.0) |
|
| lp2bp_zpk(z, p, k, wo=1.0, bw=1.0) |
|
| lp2bs(b, a, wo=1.0, bw=1.0) |
|
| lp2bs_zpk(z, p, k, wo=1.0, bw=1.0) |
|
| lp2hp(b, a, wo=1.0) |
|
| lp2hp_zpk(z, p, k, wo=1.0) |
|
| lp2lp(b, a, wo=1.0) |
|
| lp2lp_zpk(z, p, k, wo=1.0) |
|
| lsim(system, U, T, X0=None, interp=True) |
|
| max_len_seq(nbits, state=None, length=None, taps=None) |
|
| medfilt(volume, kernel_size=None) |
|
| medfilt2d(input, kernel_size=3) |
|
| minimum_phase(h: numpy.ndarray, method: Literal['homomorphic', 'hilbert'] = 'homomorphic', n_fft: int | None = None, *, half: bool = True) -> numpy.ndarray |
Convert a linear-phase FIR filter to minimum phase [extrait de minimum_phase.__doc__] |
| normalize(b, a) |
Normalize numerator/denominator of a continuous-time transfer function. [extrait de normalize.__doc__] |
| oaconvolve(in1, in2, mode='full', axes=None) |
Convolve two N-dimensional arrays using the overlap-add method. [extrait de oaconvolve.__doc__] |
| order_filter(a, domain, rank) |
|
| peak_prominences(x, peaks, wlen=None) |
|
| peak_widths(x, peaks, rel_height=0.5, prominence_data=None, wlen=None) |
|
| periodogram(x, fs=1.0, window='boxcar', nfft=None, detrend='constant', return_onesided=True, scaling='density', axis=-1) |
|
| place_poles(A, B, poles, method='YT', rtol=0.001, maxiter=30) |
|
| qspline1d(signal, lamb=0.0) |
Compute quadratic spline coefficients for rank-1 array. [extrait de qspline1d.__doc__] |
| qspline1d_eval(cj, newx, dx=1.0, x0=0) |
Evaluate a quadratic spline at the new set of points. [extrait de qspline1d_eval.__doc__] |
| qspline2d(signal, lamb=0.0, precision=-1.0) |
|
| remez(numtaps, bands, desired, *, weight=None, type='bandpass', maxiter=25, grid_density=16, fs=None) |
|
| resample(x, num, t=None, axis=0, window=None, domain='time') |
|
| resample_poly(x, up, down, axis=0, window=('kaiser', 5.0), padtype='constant', cval=None) |
|
| residue(b, a, tol=0.001, rtype='avg') |
Compute partial-fraction expansion of b(s) / a(s). [extrait de residue.__doc__] |
| residuez(b, a, tol=0.001, rtype='avg') |
Compute partial-fraction expansion of b(z) / a(z). [extrait de residuez.__doc__] |
| savgol_coeffs(window_length, polyorder, deriv=0, delta=1.0, pos=None, use='conv') |
Compute the coefficients for a 1-D Savitzky-Golay FIR filter. [extrait de savgol_coeffs.__doc__] |
| savgol_filter(x, window_length, polyorder, deriv=0, delta=1.0, axis=-1, mode='interp', cval=0.0) |
Apply a Savitzky-Golay filter to an array. [extrait de savgol_filter.__doc__] |
| sawtooth(t, width=1) |
|
| sepfir2d |
out = sepfir2d(input, hrow, hcol) [extrait de sepfir2d.__doc__] |
| sos2tf(sos) |
|
| sos2zpk(sos) |
|
| sosfilt(sos, x, axis=-1, zi=None) |
|
| sosfilt_zi(sos) |
|
| sosfiltfilt(sos, x, axis=-1, padtype='odd', padlen=None) |
|
| sosfreqz(*args, **kwargs) |
|
| spectrogram(x, fs=1.0, window=('tukey', 0.25), nperseg=None, noverlap=None, nfft=None, detrend='constant', return_onesided=True, scaling='density', axis=-1, mode='psd') |
Compute a spectrogram with consecutive Fourier transforms (legacy function). [extrait de spectrogram.__doc__] |
| spline_filter(Iin, lmbda=5.0) |
Smoothing spline (cubic) filtering of a rank-2 array. [extrait de spline_filter.__doc__] |
| square(t, duty=0.5) |
|
| ss2tf(A, B, C, D, input=0) |
State-space to transfer function. [extrait de ss2tf.__doc__] |
| ss2zpk(A, B, C, D, input=0) |
State-space representation to zero-pole-gain representation. [extrait de ss2zpk.__doc__] |
| step(system, X0=None, T=None, N=None) |
Step response of continuous-time system. [extrait de step.__doc__] |
| stft(x, fs=1.0, window='hann', nperseg=256, noverlap=None, nfft=None, detrend=False, return_onesided=True, boundary='zeros', padded=True, axis=-1, scaling='spectrum') |
Compute the Short Time Fourier Transform (legacy function). [extrait de stft.__doc__] |
| sweep_poly(t, poly, phi=0) |
|
| symiirorder1(signal, c0, z1, precision=-1.0) |
|
| symiirorder2(input, r, omega, precision=-1.0) |
|
| test(label='fast', verbose=1, extra_argv=None, doctests=False, coverage=False, tests=None, parallel=None) |
|
| tf2sos(b, a, pairing=None, *, analog=False) |
|
| tf2ss(num, den) |
Transfer function to state-space representation. [extrait de tf2ss.__doc__] |
| tf2zpk(b, a) |
Return zero, pole, gain (z, p, k) representation from a numerator, [extrait de tf2zpk.__doc__] |
| unique_roots(p, tol=0.001, rtype='min') |
Determine unique roots and their multiplicities from a list of roots. [extrait de unique_roots.__doc__] |
| unit_impulse(shape, idx=None, dtype=<class 'float'>) |
|
| upfirdn(h, x, up=1, down=1, axis=-1, mode='constant', cval=0) |
Upsample, FIR filter, and downsample. [extrait de upfirdn.__doc__] |
| vectorstrength(events, period) |
|
| welch(x, fs=1.0, window='hann', nperseg=None, noverlap=None, nfft=None, detrend='constant', return_onesided=True, scaling='density', axis=-1, average='mean') |
|
| wiener(im, mysize=None, noise=None) |
|
| zoom_fft(x, fn, m=None, *, fs=2, endpoint=False, axis=-1) |
|
| zpk2sos(z, p, k, pairing=None, *, analog=False) |
Return second-order sections from zeros, poles, and gain of a system [extrait de zpk2sos.__doc__] |
| zpk2ss(z, p, k) |
Zero-pole-gain representation to state-space representation [extrait de zpk2ss.__doc__] |
| zpk2tf(z, p, k) |
|
Améliorations / Corrections
Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.
Emplacement :
Description des améliorations :