(To be removed) Equalize signal using equalizer object

**equalize will be removed in a future release. Use comm.LinearEqualizer or comm.DecisionFeedback instead.**

`y = equalize(eqobj,x)`

y = equalize(eqobj,x,trainsig)

[y,yd] = equalize(...)

[y,yd,e] = equalize(...)

`y = equalize(eqobj,x)`

processes the baseband
signal vector `x`

with equalizer object `eqobj`

and
returns the equalized signal vector `y`

. At the end of the process,
`eqobj`

contains updated state information such as equalizer weight
values and input buffer values. To construct `eqobj`

, use the
`lineareq`

or `dfe`

function. The
`equalize`

function assumes that the signal `x`

is sampled at `nsamp`

samples per symbol, where
`nsamp`

is the value of the `nSampPerSym`

property
of `eqobj`

. For adaptive algorithms other than CMA, the equalizer
adapts in decision-directed mode using a detector specified by the
`SigConst`

property of `eqobj`

. The delay of the
equalizer is `(eqobj.RefTap-1)/eqobj.nSampPerSym`

.

Note that `(eqobj.RefTap-1)`

must be an integer multiple of
`nSampPerSym`

. For a fractionally-spaced equalizer, the taps are
spaced at fractions of a symbol period. The reference tap pertains to training symbols,
and thus, must coincide with a whole number of symbols (i.e., an integer number of
samples per symbol). `eqobj.RefTap=1`

corresponds to the first symbol,
`eqobj.RefTap=nSampPerSym+1`

to the second, and so on. Therefore
`(eqobj.RefTap-1)`

must be an integer multiple of
`nSampPerSym`

.

If `eqobj.ResetBeforeFiltering`

is `0`

,
`equalize`

uses the existing state information in
`eqobj`

when starting the equalization operation. As a result,
`equalize(eqobj,[x1 x2])`

is equivalent to
`[equalize(eqobj,x1) equalize(eqobj,x2)]`

. To reset
`eqobj`

manually, apply the `reset`

function to
`eqobj`

.

If `eqobj.ResetBeforeFiltering`

is `1`

,
`equalize`

resets `eqobj`

before starting the
equalization operation, overwriting any previous state information in
`eqobj`

.

`y = equalize(eqobj,x,trainsig)`

initially
uses a training sequence to adapt the equalizer. After processing the training sequence,
the equalizer adapts in decision-directed mode. The vector length of
`trainsig`

must be less than or equal to
`length(x)-(eqobj.RefTap-1)/eqobj.nSampPerSym`

.

`[y,yd] = equalize(...)`

returns the vector
`yd`

of detected data symbols.

`[y,yd,e] = equalize(...)`

returns the result
of the error calculation. For adaptive algorithms other than CMA, `e`

is the vector of errors between `y`

and the reference signal, where the
reference signal consists of the training sequence or detected symbols.

`equalize`

will be removedequalize will be removed. Use `comm.LinearEqualizer`

or `comm.DecisionFeedback`

instead.