Filter data with filter object

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

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(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?