Note: This page has been translated by MathWorks. Please click here

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

Filter data with filter object

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

`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).

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.

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

Was this topic helpful?