Built-in Mathematica Symbol

ListConvolve

ListConvolve[ker, list]
forms the convolution of the kernel ker with list.

ListConvolve[ker, list, k]
forms the cyclic convolution in which the k

element of ker is aligned with each element in list.

ListConvolve[ker, list, {k_L, k_R}]
forms the cyclic convolution whose first element contains list[[1]]ker[[k_L]] and whose last element contains list[[-1]]ker[[k_R]].

ListConvolve[ker, list, klist, p]
forms the convolution in which list is padded at each end with repetitions of the element p.

ListConvolve[ker, list, klist, {p₁, p₂, ...}]
forms the convolution in which list is padded at each end with cyclic repetitions of the p_i.

ListConvolve[ker, list, klist, padding, g, h]
forms a generalized convolution in which g is used in place of Times and h in place of Plus.

ListConvolve[ker, list, klist, padding, g, h, lev]
forms a convolution using elements at level lev in ker and list.

MORE INFORMATION

With kernel K_r and list a_s, ListConvolve[ker, list] computes , where the limits of the sum are such that the kernel never overhangs either end of the list.

ListConvolve[ker, list] gives a result of length Length[list]-Length[ker]+1.

ListConvolve[ker, list] allows no overhangs and is equivalent to ListConvolve[ker, list, {-1, 1}].

ListConvolve[ker, list, k] is equivalent to ListConvolve[ker, list, {k, k}].

The values of k_L and k_R in ListConvolve[ker, list, {k_L, k_R}] determine the amount of overhang to allow at each end of list.

Common settings for {k_L, k_R} are:

	{-1,1}	no overhangs (default)
	{-1,-1}	maximal overhang at the right-hand end
	{1,1}	maximal overhang at the left-hand end
	{1,-1}	maximal overhangs at both beginning and end

With maximal overhang at one end only, the result from ListConvolve is the same length as list.

ListConvolve[ker, list, {k_L, k_R}, padlist] effectively lays down repeated copies of padlist, then superimposes one copy of list on them and forms a convolution of the result.

Common settings for padlist are:

	p	pad with repetitions of a single element
	{p₁,p₂,...}	pad with cyclic repetitions of a sequence of elements
	list	pad by treating list as cyclic (default)
	{}	do no padding

ListConvolve works with multidimensional kernels and lists of data.

ListConvolve[ker, list, {{k_L1, k_L2, ...}, {k_R1, k_R2, ...}}] forms the cyclic convolution whose {1, 1, ...} element contains ker[[k_L1, k_L2, ...]]list[[1, 1, ...]] and whose {-1, -1, ...} element contains ker[[k_R1, k_R2, ...]]list[[-1, -1, ...]].

{k_L, k_R} is taken to be equivalent to {{k_L, k_L, ...}, {k_R, k_R, ...}}.

When a function h is specified to use in place of Plus, explicit nested h expressions are generated with a depth equal to the depth of ker.

ListConvolve works with exact numbers and symbolic data as well as approximate numbers.

EXAMPLES

CLOSE ALL

Basic Examples (4)

Convolve a kernel {x, y} with a list of data:

Make a cyclic convolution the same length as the original data:

Align element 2 in the kernel with successive elements in the data:

Pad with zzz instead of using the data cyclically:

Two-dimensional convolution:

Convolve a kernel {x, y} with a list of data:

In[1]:=

Out[1]=

Make a cyclic convolution the same length as the original data:

In[1]:=

Out[1]=

Align element 2 in the kernel with successive elements in the data:

In[2]:=

Out[2]=

Pad with zzz instead of using the data cyclically:

In[1]:=

Out[1]=

Two-dimensional convolution:

In[1]:=

Out[1]=

Scope (9)

"Slide" the kernel along the data, allowing no overhangs:

Maximal overhang at the beginning; none at the end:

Maximal overhang at the end; none at the beginning:

Maximal overhangs at both beginning and end:

Align element 1 of the kernel with the first element of the data:

Align element 2 of the kernel with the first element of the data:

Align element 3 of the kernel with the first element of the data:

Align the last element of the kernel with the first element of the data:

Align the first element of the kernel with both the first and last elements of the data:

Align element 2 of the kernel with the first element of the data:

Align element 2 of the kernel with the last element of the data:

Use padding aa:

Cyclically use a list of padding elements:

Allow no overhangs:

Align with the {1, 1} elements of the kernel and data:

The result has the same dimensions as the input data:

Give a different overhang in each dimension:

Generalizations & Extensions (3)

ListConvolve works with sparse arrays:

Use f in place of Times:

Use g in place of Plus:

Use f and g in place of Times and Plus, with empty data padding:

Applications (9)

Find a moving average:

Or use the MovingAverage function:

Smooth noisy data:

Find the autocorrelation of a list:

Apply a simple image-processing filter:

Multiply polynomials by convolving coefficient lists:

Multiply numbers by convolving digit lists:

Pascal's triangle:

Additive cellular automaton in base 5:

Fast multiplication of high-degree polynomials:

Use ListConvolve with maximal overhangs and zero padding:

Properties & Relations (7)

Cyclic convolution is equivalent to multiplication in the discrete Fourier transform domain:

Convolve with a single element:

A kernel of the same length as the data, with no overhangs, is like a reversed dot product:

Successive differences:

Align with successive elements:

Varying alignments:

Varying alignments, with padding:

Possible Issues (1)

By default, the output is not the same length as the input:

Use overhangs to make the output the same length as the input:

Use overhangs to do the same in 2D: