## Filter Implementation

### Convolution and Filtering

The mathematical foundation of filtering is convolution. For a finite impulse response
(FIR) filter, the output *y*(*k*) of a filtering operation is the convolution of the input signal *x*(*k*) with the impulse response *h*(*k*):

$$y(k)={\displaystyle \sum _{l=-\infty}^{\infty}h}(l)\text{\hspace{0.17em}}x(k-l).$$

If the input signal is also of finite length, you can implement the filtering operation
using the MATLAB^{®}
`conv`

function. For example, to filter a five-sample random vector with a
third-order averaging filter, you can store *x*(*k*) in a vector `x`

, *h*(*k*) in a vector `h`

, and convolve the
two:

```
x = randn(5,1);
h = [1 1 1 1]/4; % A third-order filter has length 4
y = conv(h,x)
```

y = -0.3375 0.4213 0.6026 0.5868 1.1030 0.3443 0.1629 0.1787

`y`

is one less than the sum of the lengths of
`x`

and `h`

.### Filters and Transfer Functions

The transfer function of a filter is the Z-transform of its impulse response. For an FIR
filter, the Z-transform of the output *y*, *Y*(*z*), is the product of the transfer function and *X*(*z*), the Z-transform of the input *x*:

$$Y(z)=H(z)X(z)=\left(h(1)+h(2){z}^{-1}+\cdots +h(n+1){z}^{-n}\right)X(z).$$

The polynomial coefficients *h*(1), *h*(2), …,
*h*(*n* + 1) correspond to the coefficients of the impulse response of an
*n*th-order filter.

**Note**

The filter coefficient indices run from 1 to (*n* + 1), rather than
from 0 to *n*. This reflects the standard indexing scheme used for
MATLAB vectors.

FIR filters are also called all-zero, nonrecursive, or moving-average (MA) filters.

For an infinite impulse response (IIR) filter, the transfer function is not a polynomial, but a rational function. The Z-transforms of the input and output signals are related by

$$Y(z)=H(z)X(z)=\frac{b(1)+b(2){z}^{-1}+\mathrm{...}+b(n+1){z}^{-n}}{a(1)+a(2){z}^{-1}+\mathrm{...}+a(m+1){z}^{-m}}X(z),$$

where *b*(*i*) and
*a*(*i*) are the filter coefficients. In this case, the
order of the filter is the maximum of *n* and *m*. IIR
filters with *n* = 0 are also called all-pole, recursive, or autoregressive
(AR) filters. IIR filters with both *n* and *m* greater
than zero are also called pole-zero, recursive, or autoregressive moving-average (ARMA)
filters. The acronyms AR, MA, and ARMA are usually applied to filters associated with
filtered stochastic processes.

### Filtering with the `filter`

Function

For IIR filters, the filtering operation is described not by a simple convolution, but
by a difference equation that can be found from the transfer-function relation. Assume that *a*(1) = 1, move the denominator to the left side, and take the inverse Z-transform
to obtain

$$y(k)+a(2)\text{\hspace{0.17em}}y(k-1)+\dots +a(m+1)\text{\hspace{0.17em}}y(k-m)=b(1)\text{\hspace{0.17em}}x(k)+b(2)\text{\hspace{0.17em}}x(k-1)+\cdots +b(n+1)\text{\hspace{0.17em}}x(k-n).$$

In terms of current and past inputs, and past outputs,
*y*(*k*) is

$$y(k)=b(1)\text{\hspace{0.17em}}x(k)+b(2)\text{\hspace{0.17em}}x(k-1)+\cdots +b(n+1)\text{\hspace{0.17em}}x(k-n)-a(2)\text{\hspace{0.17em}}y(k-1)-\cdots -a(m+1)\text{\hspace{0.17em}}y(k-m),$$

which is the standard time-domain representation of a digital filter. Starting with
*y*(1) and assuming a causal system with zero initial conditions, the
representation is equivalent to

$$\begin{array}{l}y(1)=b(1)\text{\hspace{0.17em}}x(1)\\ y(2)=b(1)\text{\hspace{0.17em}}x(2)+b(2)\text{\hspace{0.17em}}x(1)-a(2)\text{\hspace{0.17em}}y(1)\\ y(3)=b(1)\text{\hspace{0.17em}}x(3)+b(2)\text{\hspace{0.17em}}x(2)+b(3)\text{\hspace{0.17em}}x(1)-a(2)\text{\hspace{0.17em}}y(2)-a(3)\text{\hspace{0.17em}}y(1)\\ \text{\hspace{1em}}\text{\hspace{1em}}\vdots \text{\hspace{0.05em}}\text{\hspace{0.05em}}\text{\hspace{0.05em}}\\ y(n)=b(1)\text{\hspace{0.17em}}x(n)+\cdots +b(n)\text{\hspace{0.17em}}x(1)-a(2)\text{\hspace{0.17em}}y(n-1)-\cdots -a(n)\text{\hspace{0.17em}}y(1).\end{array}$$

To implement this filtering operation, you can use the MATLAB
`filter`

function. `filter`

stores the coefficients in two
row vectors, one for the numerator and one for the denominator. For example, to solve the
difference equation

$$y(n)-0.9y(n-1)=x(n)\text{\hspace{1em}}\Rightarrow \text{\hspace{1em}}Y(z)=\frac{1}{1-0.9\text{\hspace{0.17em}}{z}^{-1}}X(z)=H(z)\text{\hspace{0.17em}}X(z),$$

you can use

b = 1; a = [1 -0.9]; y = filter(b,a,x);

`filter`

gives you as many output samples as there are input samples, that is, the length of
`y`

is the same as the length of `x`

. If the first
element of *a*is not 1, then

`filter`

divides the
coefficients by *a*(1) before implementing the difference equation.

## See Also

### Apps

### Functions

`conv`

|`designfilt`

|`filter`