| 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) |
|
| barthann(*args, **kwargs) |
Return a modified Bartlett-Hann window. [extrait de barthann.__doc__] |
| bartlett(*args, **kwargs) |
|
| 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) |
|
| blackman(*args, **kwargs) |
|
| blackmanharris(*args, **kwargs) |
Return a minimum 4-term Blackman-Harris window. [extrait de blackmanharris.__doc__] |
| bode(system, w=None, n=100) |
|
| bohman(*args, **kwargs) |
Return a Bohman window. [extrait de bohman.__doc__] |
| boxcar(*args, **kwargs) |
Return a boxcar or rectangular window. [extrait de boxcar.__doc__] |
| bspline(x, n) |
B-spline basis function of order n. [extrait de bspline.__doc__] |
| 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__] |
| cascade(hk, J=7) |
|
| 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__] |
| chebwin(*args, **kwargs) |
Return a Dolph-Chebyshev window. [extrait de chebwin.__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) |
Frequency-swept cosine generator. [extrait de chirp.__doc__] |
| choose_conv_method(in1, in2, mode='full', measure=False) |
|
| cmplx_sort(p) |
Sort roots based on magnitude. [extrait de cmplx_sort.__doc__] |
| 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') |
|
| cosine(*args, **kwargs) |
Return a window with a simple cosine shape. [extrait de cosine.__doc__] |
| 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 |
out = cspline2d(input, lambda=0.0, precision=-1.0) [extrait de cspline2d.__doc__] |
| cubic(x) |
A cubic B-spline. [extrait de cubic.__doc__] |
| cwt(data, wavelet, widths, dtype=None, **kwargs) |
|
| daub(p) |
|
| 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, axis=-1, type='linear', bp=0, overwrite_data=False) |
|
| 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__] |
| exponential(*args, **kwargs) |
Return an exponential (or Poisson) window. [extrait de exponential.__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, nyq=None, fs=None) |
|
| firwin(numtaps, cutoff, width=None, window='hamming', pass_zero=True, scale=True, nyq=None, fs=None) |
|
| firwin2(numtaps, freq, gain, nfreqs=None, window='hamming', nyq=None, antisymmetric=False, fs=None) |
|
| flattop(*args, **kwargs) |
Return a flat top window. [extrait de flattop.__doc__] |
| 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_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__] |
| gaussian(*args, **kwargs) |
Return a Gaussian window. [extrait de gaussian.__doc__] |
| gausspulse(t, fc=1000, bw=0.5, bwr=-6, tpr=-60, retquad=False, retenv=False) |
|
| general_gaussian(*args, **kwargs) |
Return a window with a generalized Gaussian shape. [extrait de general_gaussian.__doc__] |
| 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__] |
| hamming(*args, **kwargs) |
Return a Hamming window. [extrait de hamming.__doc__] |
| hann(*args, **kwargs) |
|
| hanning(*args, **kwds) |
`hanning` is deprecated, use `scipy.signal.windows.hann` instead! [extrait de hanning.__doc__] |
| hilbert(x, N=None, axis=-1) |
|
| hilbert2(x, N=None) |
|
| iircomb(w0, Q, ftype='notch', fs=2.0) |
|
| 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__] |
| impulse2(system, X0=None, T=None, N=None, **kwargs) |
|
| 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) |
Perform the inverse Short Time Fourier transform (iSTFT). [extrait de istft.__doc__] |
| kaiser(*args, **kwargs) |
Return a Kaiser window. [extrait de kaiser.__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, y, freqs, precenter=False, normalize=False) |
|
| 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) |
|
| lsim2(system, U=None, T=None, X0=None, **kwargs) |
|
| max_len_seq(nbits, state=None, length=None, taps=None) |
|
| medfilt(volume, kernel_size=None) |
|
| medfilt2d(input, kernel_size=3) |
|
| minimum_phase(h, method='homomorphic', n_fft=None) |
Convert a linear-phase FIR filter to minimum phase [extrait de minimum_phase.__doc__] |
| morlet(M, w=5.0, s=1.0, complete=True) |
|
| morlet2(M, s, w=5) |
|
| normalize(b, a) |
Normalize numerator/denominator of a continuous-time transfer function. [extrait de normalize.__doc__] |
| nuttall(*args, **kwargs) |
Return a minimum 4-term Blackman-Harris window according to Nuttall. [extrait de nuttall.__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) |
|
| parzen(*args, **kwargs) |
Return a Parzen window. [extrait de parzen.__doc__] |
| 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) |
|
| qmf(hk) |
|
| 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 |
out = qspline2d(input, lambda=0.0, precision=-1.0) [extrait de qspline2d.__doc__] |
| quadratic(x) |
A quadratic B-spline. [extrait de quadratic.__doc__] |
| remez(numtaps, bands, desired, weight=None, Hz=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__] |
| ricker(points, a) |
|
| 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(sos, worN=512, whole=False, fs=6.283185307179586) |
|
| 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. [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__] |
| step2(system, X0=None, T=None, N=None, **kwargs) |
Step response of continuous-time system. [extrait de step2.__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) |
Compute the Short Time Fourier Transform (STFT). [extrait de stft.__doc__] |
| sweep_poly(t, poly, phi=0) |
|
| symiirorder1 |
out = symiirorder1(input, c0, z1, precision=-1.0) [extrait de symiirorder1.__doc__] |
| symiirorder2 |
out = symiirorder2(input, r, omega, precision=-1.0) [extrait de symiirorder2.__doc__] |
| test(label='fast', verbose=1, extra_argv=None, doctests=False, coverage=False, tests=None, parallel=None) |
|
| tf2sos(b, a, pairing='nearest') |
|
| 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__] |
| triang(*args, **kwargs) |
Return a triangular window. [extrait de triang.__doc__] |
| tukey(*args, **kwargs) |
Return a Tukey window, also known as a tapered cosine window. [extrait de tukey.__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) |
|
| zpk2sos(z, p, k, pairing='nearest') |
|
| 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 :