jax.numpy.convolve¶
-
jax.numpy.
convolve
(a, v, mode='full', *, precision=None)[source]¶ Returns the discrete, linear convolution of two one-dimensional sequences.
LAX-backend implementation of
convolve()
. In addition to the original NumPy arguments listed below, also supportsprecision
for extra control over matrix-multiplication precision on supported devices.precision
may be set toNone
, which means default precision for the backend, alax.Precision
enum value (Precision.DEFAULT
,Precision.HIGH
orPrecision.HIGHEST
) or a tuple of twolax.Precision
enums indicating separate precision for each argument.Original docstring below.
The convolution operator is often seen in signal processing, where it models the effect of a linear time-invariant system on a signal 1. In probability theory, the sum of two independent random variables is distributed according to the convolution of their individual distributions.
If v is longer than a, the arrays are swapped before computation.
- Parameters
a ((N,) array_like) – First one-dimensional input array.
v ((M,) array_like) – Second one-dimensional input array.
mode ({'full', 'valid', 'same'}, optional) –
- ‘full’:
By default, mode is ‘full’. This returns the convolution at each point of overlap, with an output shape of (N+M-1,). At the end-points of the convolution, the signals do not overlap completely, and boundary effects may be seen.
- Returns
out – Discrete, linear convolution of a and v.
- Return type
See also
scipy.signal.fftconvolve()
Convolve two arrays using the Fast Fourier Transform.
scipy.linalg.toeplitz()
Used to construct the convolution operator.
polymul()
Polynomial multiplication. Same output as convolve, but also accepts poly1d objects as input.
Notes
The discrete convolution operation is defined as
\[(a * v)[n] = \sum_{m = -\infty}^{\infty} a[m] v[n - m]\]It can be shown that a convolution \(x(t) * y(t)\) in time/space is equivalent to the multiplication \(X(f) Y(f)\) in the Fourier domain, after appropriate padding (padding is necessary to prevent circular convolution). Since multiplication is more efficient (faster) than convolution, the function scipy.signal.fftconvolve exploits the FFT to calculate the convolution of large data-sets.
References
- 1
Wikipedia, “Convolution”, https://en.wikipedia.org/wiki/Convolution
Examples
Note how the convolution operator flips the second array before “sliding” the two across one another:
>>> np.convolve([1, 2, 3], [0, 1, 0.5]) array([0. , 1. , 2.5, 4. , 1.5])
Only return the middle values of the convolution. Contains boundary effects, where zeros are taken into account:
>>> np.convolve([1,2,3],[0,1,0.5], 'same') array([1. , 2.5, 4. ])
The two arrays are of the same length, so there is only one position where they completely overlap:
>>> np.convolve([1,2,3],[0,1,0.5], 'valid') array([2.5])