WOLFRAM

Wolfram Language & System Documentation Center
Digital Filter Design

Digital Filter Design

Digital Filter Design MethodsOutput Response—Digital Filtering of Signals
Poles and Zeros of Digital Filters
The Wolfram Language provides a comprehensive set of methods for designing digital filters.
Digital Filter Design Methods
LeastSquaresFilterKernel
create an FIR filter using the least-squares method
FrequencySamplingFilterKernel
create an FIR filter using frequency sampling
EquirippleFilterKernel
create an FIR filter using the equiripple method
ToDiscreteTimeModel
create an IIR digital filter from an analog prototype
Digital filter design methods.

Least-Squares Method

This method obtains a finite impulse response (FIR) from a given prototype filter specification in the frequency domain by means of the inverse discrete-time Fourier transform.
Define a zero-phase ideal lowpass filter with a cutoff frequency of 1.2 radians per sample.
H( j ω){
1,|ω| ≤ ωc
0,otherwise
The impulse response is obtained by taking the inverse discrete-time Fourier transform of the filter specification:
Wolfram Language code: InverseFourierSequenceTransform[UnitBox[ω / 2.4], ω, n, FourierParameters -> {1, -1}]
Evaluating this expression for integer values of from to will return a filter of length .
Create a lowpass FIR filter of length 15 with a cutoff frequency of 1.2 radians per sample:
Wolfram Language code: h = LeastSquaresFilterKernel[{"Lowpass", 1.2}, 15]
This method minimizes the mean-squared error between the ideal specification and the resulting FIR filter:
Wolfram Language code: Plot[{Abs[ListFourierSequenceTransform[h, x]], Piecewise[{{1, 0 ≤ x ≤ 1.2}}]}, {x, 0, π}, PlotRange -> All, Exclusions -> False, Filling -> {1 -> {2}}]
The least-squares method is also known as the window-based method. The mean-squared error can be diminished by applying a smoothing window to the FIR returned by LeastSquaresFilterKernel.
Create a Hann window of length 15:
Wolfram Language code: win = Array[HannWindow, 15, {-0.5, 0.5}]
Apply the window to the lowpass FIR filter h:
Wolfram Language code: h2 = win h; Plot[Evaluate[20 Log[10, Abs[ListFourierSequenceTransform[#, x]]]& /@ {h, h2}], {x, 0, π}, ImageSize -> 300]
Different windows return different attenuations. Select a window type by the degree of the desired attenuation.
Compare attenuation levels of four selected windows
Wolfram Language code: With[{wins = {DirichletWindow, BartlettWindow, HannWindow, BlackmanWindow}}, f = FourierTransform[#[x], x, w]& /@ wins; LogLinearPlot[Evaluate[20 Log[10, Abs[#] / Limit[#, w -> 0]]& /@ f], {w, 1, 100}, PlotRange -> {0, -100}, PlotLegends -> wins]]

Frequency Sampling Method

Frequency sampling allows the creation of an FIR filter by specifying the filter's amplitude spectrum on the interval 0≤ ω≤ π at a finite number of uniformly spaced frequency locations.
Sample an ideal lowpass filter at for from 0 to 5:
Wolfram Language code: t = Table[{x, UnitBox[x / (0.9 π)]}, {x, 0, 3, 2π / 11}]
Wolfram Language code: Show[{Plot[UnitBox[x / (0.9 π)], {x, 0, π}, Exclusions -> None], ListPlot[t, PlotRange -> All, PlotStyle -> {Red, PointSize[Large]}, Filling -> 0, FillingStyle -> Red]}]
Create an odd-length, even-symmetry lowpass filter:
Wolfram Language code: {frequencies, amplitudes} = Transpose[t]; FrequencySamplingFilterKernel[amplitudes, 1]
Show the ideal lowpass filter, amplitude samples, and the resulting filter:
Wolfram Language code: Show[{ListPlot[t, PlotRange -> {{0, π}, {-0.2, 1.2}}, PlotStyle -> {Red, PointSize[Large]}, Filling -> Axis, AxesLabel -> {ω, None}, Ticks -> {Automatic, {0., 0.5, 1.}}], Plot[{UnitBox[ω / (0.9 π)], Evaluate[Abs[ListFourierSequenceTransform[FrequencySamplingFilterKernel[amplitudes, 1], ω]]]}, {ω, 0, π}, Exclusions -> None]}]

Equiripple Method

The Parks–McClellan–Rabiner (1979) algorithm is one of the most popular methods of designing linear-phase FIR filters. It minimizes the maximum deviation from the desired ideal frequency response and results in filters with equal ripples in each of the bands of the filter.
Create a multiband filter of length 55:
Wolfram Language code: EquirippleFilterKernel[{{{0., 0.05}, {.1, 0.15}, {0.18, 0.25}, {0.3, 0.36}, {0.41, 0.5}} 2 π, {0., 1., 0., 1., 0.}, {10., 1., 3., 1., 20.}}, 55]
Plot the magnitude response of an equiripple multiband filter:
Wolfram Language code: Plot[20 Log[10, Abs[ListFourierSequenceTransform[%, ω]]], {ω, 0, π}, PlotRange -> All, GridLines -> Automatic]

Create a Digital Filter from an Analog Prototype

A popular method of creating digital filters is to transform analog prototypes to their digital equivalents using the bilinear transformation. The result is an infinite impulse response (IIR) filter, represented as a TransferFunctionModel.
ToDiscreteTimeModel
discrete-time approximation of an analog filter
Create an IIR filter from an analog prototype.
Create an analog lowpass filter of Chebyshev type with a cutoff frequency at radians per second:
Wolfram Language code: tfa = TransferFunctionExpand[Chebyshev1FilterModel[{"Lowpass", {1., 3.}, {1., 40.}}, s]]//Chop
Transform the analog filter to a digital filter using bilinear transformation:
Wolfram Language code: tfd = ToDiscreteTimeModel[tfa, 1, z, Method -> {"BilinearTransform"}]//Chop
Show the frequency response of the resulting IIR filter:
Wolfram Language code: GraphicsRow[{Plot[Abs[tfd[E^I ω]]^2, {ω, 0, π}, AxesLabel -> {ω, None}, GridLines -> Automatic, AspectRatio -> 1 / 3], BodePlot[tfd, {0.1, N[π]}, GridLines -> Automatic, PlotLayout -> List]//First}]
Poles and Zeros of Digital Filters
TransferFunctionPoles
extract poles of analog filters
TransferFunctionZeros
extract zeros of analog filters
Poles and zeros of analog filters.
Compute and show zeros of a lowpass filter:
Wolfram Language code: h = LeastSquaresFilterKernel[{"Lowpass", 1.2}, 9]; H = ListZTransform[h, z]
Wolfram Language code: tf = TransferFunctionModel[H, z, SamplingPeriod -> 1]//TransferFunctionCancel
Wolfram Language code: zeros = Flatten@TransferFunctionZeros[tf]
Wolfram Language code: ListPlot[Transpose[{Re[zeros], Im[zeros]}], PlotRange -> 2.2{{-1, 1}, {-1, 1}}, PlotStyle -> {PointSize[Large]}, AxesOrigin -> {0, 0}, Epilog -> {Dashed, Pink, Circle[]}, AspectRatio -> Automatic]
Output Response—Digital Filtering of Signals

FIR Filters

ListConvolve
convolve an FIR filter with data
ImageConvolve
convolve an FIR filter with image
DiscreteConvolve
symbolic convolution of two signals
Apply FIR filters to signals.
Create a lowpass equiripple filter:
Wolfram Language code: h = LeastSquaresFilterKernel[{"Lowpass", 0.5}, 21]; Plot[{Abs[ListFourierSequenceTransform[h, x]], Piecewise[{{1, 0 ≤ x ≤ .5}}]}, {x, 0, π}, PlotRange -> All, Exclusions -> False]
Import and filter an audio signal:
Wolfram Language code: a = ExampleData[{"Audio", "Apollo11ReturnSafely"}, "Audio"]
Wolfram Language code: res = Audio[ListConvolve[h, AudioData[a][[1]]], SampleRate -> AudioSampleRate[a]]
Lowpass filtering of a scanline of the red channel of an image:
Wolfram Language code: img = [image]; row = ImageData[img, Interleaving -> False][[1, 100]]; ListLinePlot /@ {row, ListConvolve[(h / Total[h]), row, 12, 0]}
Lowpass filtering of an image:
Wolfram Language code: ImageConvolve[img, Outer[Times, h, h]]

IIR Filters

RecurrenceFilter
apply an IIR filter to a signal
RecurrenceTable
iteratively solve the recurrence equation
OutputResponse
output response of a filter
Apply IIR filters to signals.
Define a transfer function of a digital Butterworth filter:
Wolfram Language code: tfd = TransferFunctionModel[{{{1 + 3*z + 3*z^2 + z^3}}, -3 + 15*z - 25*z^2 + 21*z^3}, z, SamplingPeriod -> 1];
Compute the impulse response of the IIR filter:
Wolfram Language code: input = N@ArrayPad[{1}, {0, 20}]; RecurrenceFilter[tfd, input]
Compute the impulse response by using the coefficients of the transfer function model:
Wolfram Language code: RecurrenceFilter[{{21., -25., 15., -3. }, {1., 3., 3., 1.}}, input]
Compute the impulse response using OutputResponse:
Wolfram Language code: OutputResponse[tfd, input]
Compute the impulse response by solving the corresponding recurrence equation model of the filter using RecurrenceTable:
Wolfram Language code: Module[{x, y}, x[n_] := DiscreteDelta[n]; RecurrenceTable[{21y[n] - 25 y[n - 1] + 15 y[n - 2] - 3 y[n - 3] == x[n] + 3 x[n - 1] + 3 x[n - 2] + x[n - 3], y[-1] == 0, y[-2] == 0, y[-3] == 0}, y, {n, 0, 20}]//N]
Lowpass filtering of a scanline of the red channel of an image:
Wolfram Language code: img = [image]; row = ImageData[img, Interleaving -> False][[1, 100]]; ListLinePlot /@ {row, RecurrenceFilter[tfd, row]}
Lowpass filtering of an image:
Wolfram Language code: RecurrenceFilter[tfd, img]