Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://reference.wolfram.com/language/ref/ListConvolve.html below:

ListConvolve—Wolfram Language Documentation

We deliver solutions for the AI era—combining symbolic computation, data-driven insights and deep technology expertise.

• Data & Computational Intelligence
• Model-Based Design
• Algorithm Development
• Wolfram|Alpha for Business
• Blockchain Technology
• Education Technology
• Quantum Computation

WolframConsulting.com

• See Also
  • ListCorrelate
  • ListDeconvolve
  • ImageConvolve
  • LinearRecurrence
  • MovingAverage
  • RecurrenceFilter
  • BlockMap
  • Partition
  • Accumulate
  • Differences
  • Inner
  • CellularAutomaton
  • ArrayFilter
  • PadLeft
  • DiscreteConvolve
  • ToeplitzMatrix
  • DiskMatrix
  • GaussianMatrix
• Related Guides
  • Data Transforms and Smoothing
  • Signal Processing
  • Signal Filtering & Filter Design
  • Handling Arrays of Data
  • Linear and Nonlinear Filters
  • Image Filtering & Neighborhood Processing
  • Fourier Analysis
  • Numerical Data
  • Scientific Data Analysis
  • Summation Transforms
• Tech Notes
  • Convolutions and Correlations
  • Implementation notes: Numerical and Related Functions

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.

• 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_{L 1},k_{L 2},…},{k_{R 1},k_{R 2},…}}] forms the cyclic convolution whose {1,1,…} element contains ker[[k_{L 1},k_{L 2},…]]list[[1,1,…]], and whose {-1,-1,…} element contains ker[[k_{R 1},k_{R 2},…]]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.

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:

"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:

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:

Generate two random vectors:

A function for constructing a circulant matrix from a vector:

Cyclic convolution is equivalent to multiplication with a circulant matrix:

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

Generate two random vectors:

A function for constructing a lower triangular Toeplitz matrix from a vector:

Cyclic convolution with zero-padding is equivalent to multiplication with a lower triangular Toeplitz matrix:

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:

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:

Introduced in 1999 (4.0)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4