## Documentation Center |

Filter data with filter object

y = filter(hd,x) y = filter(hd,x,dim)

y = filter(ha,x,d) [y,e] = filter(ha,x,d)

y = filter(hm,x) y = filter(hm,x,dim)

This reference page contains three sections that describe the syntaxes for the filter objects:

`y = filter(hd,x)` filters
a vector of real or complex input data `x` through
a fixed-point filter `hd`, producing filtered output
data `y`. The vectors `x` and `y` have
the same length. filter stores the final conditions for the filter
in the `States` property of `hd` — `hd.states`.

When you set the property `PersistentMemory` to `false` (the
default setting), the initial conditions for the filter are set to
zero before filtering starts. To use nonzero initial conditions for `hd`,
set `PersistentMemory` to `true`.
Then set `hd.states` to a vector of `nstates``(hd)` elements,
one element for each state to set. If you specify a scalar for `hd.states`, `filter` expands
the scalar to a vector of the proper length for the states. All elements
of the expanded vector have the value of the scalar.

If `x` is a matrix, `y = filter(hd,x)` filters
along each column of `x` to produce a matrix `y` of
independent channels. If `x` is a multidimensional
array, `y = filter(hd,x)` filters `x` along
the first nonsingleton dimension of `x`.

To use nonzero initial conditions when you are filtering a matrix `x`,
set the filter states to a matrix of initial condition values. Set
the initial conditions by setting the `States` property
for the filter (`hd.states`) to a matrix of `nstates(hd)` rows
and `size``(x,2)` columns.

`y = filter(hd,x,dim)` applies
the filter `hd` to the input data located along the
specific dimension of `x` specified by `dim`.

When you are filtering multichannel data, `dim` lets
you specify which dimension of the input matrix to filter along —
whether a row represents a channel or a column represents a channel.
When you provide the `dim` input argument, the filter
operates along the dimension specified by `dim`.
When your input data `x` is a vector or matrix and `dim` is
1, each column of `x` is treated as a one input channel.
When `dim` is 2, the filter treats each row of the
input `x` as a channel.

To filter multichannel data in a loop environment, you must
use the `dim` input argument to set the proper processing
dimension.

You specify the initial conditions for each channel individually,
when needed, by setting `hm.states` to a matrix of `nstates``(hd)` rows (one
row containing the states for one channel of input data) and `size(x,2)` columns
(one column containing the filter states for each channel).

`y = filter(ha,x,d)` filters
a vector of real or complex input data `x` through
an adaptive filter object `ha`, producing the estimated
desired response data `y` from the process of adapting
the filter. The vectors `x` and `y` have
the same length. Use `d` for the desired signal.
Note that `d` and `x` must be the
same length signal chains.

`[y,e] = filter(ha,x,d)` produces
the estimated desired response data `y` and the prediction
error `e` (refer to previous syntax for more information).

`y = filter(hm,x)` filters
a vector of real or complex input data `x` through
a multirate filter `hm`, producing filtered output
data `y`. The length of vectors `x` and `y` differ
by approximately the resampling factor. `filter` stores
the final conditions for the filter in the `States` property
of `hm` – `hm.states`.

`y = filter(hm,x,dim)` applies
the filter `hm` to the input data located along the
specific dimension of `x` specified by `dim`.

When you are filtering multichannel data, `dim` lets
you specify which dimension of the input matrix to filter along —
whether a row represents a channel or a column represents a channel.
When you provide the `dim` input argument, the filter
operates along the dimension specified by `dim`.
When your input data `x` is a vector or matrix and `dim` is
1, each column of `x` is treated as a one input channel.
When `dim` is 2, the filter treats each row of the
input `x` as a channel.

To filter multichannel data in a loop environment, you must
use the `dim` input argument to set the processing
dimension.

You specify the initial conditions for each channel individually,
when needed, by setting `hm.states` to a matrix of `nstates``(hm)` rows (one
row containing the states for one channel of input data) and `size(x,2)` columns
(one column containing the filter states for each channel).

The number of data samples in your input data set `x` does
not need to be a multiple of the rate change factor `r` for
the object. When the rate change factor is not an even divisor of
the number of input samples `x`, `filter` processes
the samples as shown in the following figure, where the rate change
factor is 3 and the number of input samples is 23. Decimators always
take the first input sample to generate the first output sample. After
that, the next output sample comes after each `r` number
of input samples.

Filter a signal using a filter with various initial conditions (IC) or no initial conditions.

x = randn(100,1); % Original signal. b = fir1(50,.4); % 50th-order linear-phase FIR filter. hd = dfilt.dffir(b); % Direct-form FIR implementation. % Do not set specific initial conditions. y1 = filter(hd,x); % 'PersistentMemory'='false'(default). zf = hd.states; % Final conditions.

Now use nonzero initial conditions by setting ICs after before you filter.

hd.persistentmemory = true; hd.states = 1; % Uses scalar expansion. y2 = filter(hd,x); stem([y1 y2]) % Different sequences at beginning.

Looking at the stem plot shows that the sequences are different at the beginning of the filter process.

Here is one way to use `filter` with streaming
data.

reset(hd); % Clear filter history. y3 = filter(hd,x); % Filter entire signal in one block.

As an experiment, repeat the process, filtering the data as sections, rather than in streaming form.

reset(hd); % Clear filter history. yloop = zeros(20,5); % Preallocate output array. xblock = reshape(x,[20 5]); for i=1:5, yloop(:,i) = filter(hd,xblock(:,i)); end

Use a stem plot to see the comparison between streaming and block-by-block filtering.

stem([y3 yloop(:)]);

Filtering the signal section-by-section is equivalent to filtering the entire signal at once.

To show the similarity between filtering with discrete-time and with multirate filters, this example demonstrates multirate filtering.

Fs = 44.1e3; % Original sampling frequency: 44.1kHz. n = [0:10239].'; % 10240 samples, 0.232 second long signal. x = sin(2*pi*1e3/Fs*n); % Original signal, sinusoid at 1kHz. m = 2; % Decimation factor. hm = mfilt.firdecim(m); % Use the default filter.

First, filter without setting initial conditions.

y1 = filter(hm,x); % PersistentMemory is false (default). zf = hm.states; % Final conditions.

This time, set nonzero initial conditions before filtering the data.

hm.persistentmemory = true; hm.states = 1; % Uses scalar expansion to set ICs. y2 = filter(hm,x); stem([y1(1:60) y2(1:60)]) % Show the filtering results.

Note the different sequences at the start of filtering.

Finally, try filtering streaming data.

reset(hm); % Clear the filter history. y3 = filter(hm,x); % Filter entire signal in one block.

As with the discrete-time filter, filtering the signal section by section is equivalent to filtering the entire signal at once.

reset(hm); % Clear filter history again. yloop = zeros(1024,5); % Preallocate output array. xblock = reshape(x,[2048 5]); for i=1:5, yloop(:,i) = filter(hm,xblock(:,i)); end stem([y3 yloop(:)]);

[1] Oppenheim, A.V., and R.W. Schafer, *Discrete-Time
Signal Processing*, Prentice-Hall, 1989.

Was this topic helpful?