# normlms

(Removed) Construct normalized least mean square (LMS) adaptive algorithm object

normlms has been removed. Consider using `comm.LinearEqualizer` or `comm.DecisionFeedback` instead.

## Syntax

```alg = normlms(stepsize) alg = normlms(stepsize,bias) ```

## Description

The `normlms` function creates an adaptive algorithm object that you can use with the `lineareq` function or `dfe` function to create an equalizer object. You can then use the equalizer object with the `equalize` function to equalize a signal. To learn more about the process for equalizing a signal, see Equalization.

`alg = normlms(stepsize)` constructs an adaptive algorithm object based on the normalized least mean square (LMS) algorithm with a step size of `stepsize` and a bias parameter of zero.

`alg = normlms(stepsize,bias)` sets the bias parameter of the normalized LMS algorithm. `bias` must be between 0 and 1. The algorithm uses the bias parameter to overcome difficulties when the algorithm's input signal is small.

### Properties

The table below describes the properties of the normalized LMS adaptive algorithm object. To learn how to view or change the values of an adaptive algorithm object, see Equalization.

PropertyDescription
`AlgType`Fixed value, `'Normalized LMS'`
`StepSize`LMS step size parameter, a nonnegative real number
`LeakageFactor`LMS leakage factor, a real number between 0 and 1. A value of 1 corresponds to a conventional weight update algorithm, while a value of 0 corresponds to a memoryless update algorithm.
`Bias`Normalized LMS bias parameter, a nonnegative real number

## Examples

collapse all

This example configures the recommended `comm.LinearEqualizer` System object™ and the legacy `lineareq` feature with comparable settings.

Initialize Variables and Supporting Objects

```d = randi([0 3],1000,1); x = pskmod(d,4,pi/4); r = awgn(x,25); sps = 2; %samples per symbol for oversampled cases nTaps = 6; txFilter = comm.RaisedCosineTransmitFilter('FilterSpanInSymbols',nTaps, ... 'OutputSamplesPerSymbol',4); rxFilter = comm.RaisedCosineReceiveFilter('FilterSpanInSymbols',nTaps, ... 'InputSamplesPerSymbol',4,'DecimationFactor',2); x2 = txFilter(x); r2 = rxFilter(awgn(x2,25,0.5)); filterDelay = txFilter.FilterSpanInSymbols/2 + ... rxFilter.FilterSpanInSymbols/2; % Total filter delay in symbols```

To compare the equalized output, plot the constellations using code such as:

```% plot(yNew,'*') % hold on % plot(yOld,'o') % hold off; legend('New Eq','Old Eq'); grid on```

Use LMS Algorithm with Linear Equalizer

Configure `lineareq` and `comm.LinearEqualizer` objects with comparable settings. The `LeakageFactor` property has been removed from LMS algorithm. The `comm.LinearEqualizer` System object™ assumes that leakage factor is always 1.

`eqOld = lineareq(5,lms(0.05),pskmod(0:3,4,pi/4))`
```eqOld = EqType: 'Linear Equalizer' AlgType: 'LMS' nWeights: 5 nSampPerSym: 1 RefTap: 1 SigConst: [0.7071 + 0.7071i -0.7071 + 0.7071i -0.7071 - 0.7071i 0.7071 - 0.7071i] StepSize: 0.0500 LeakageFactor: 1 Weights: [0 0 0 0 0] WeightInputs: [0 0 0 0 0] ResetBeforeFiltering: 1 NumSamplesProcessed: 0 ```
```eqNew = comm.LinearEqualizer('NumTaps',5,'Algorithm','LMS','StepSize',0.05, ... 'Constellation',pskmod(0:3,4,pi/4),'ReferenceTap',1)```
```eqNew = comm.LinearEqualizer with properties: Algorithm: 'LMS' NumTaps: 5 StepSize: 0.0500 Constellation: [0.7071 + 0.7071i -0.7071 + 0.7071i -0.7071 - 0.7071i 0.7071 - 0.7071i] ReferenceTap: 1 InputDelay: 0 InputSamplesPerSymbol: 1 TrainingFlagInputPort: false AdaptAfterTraining: true InitialWeightsSource: 'Auto' WeightUpdatePeriod: 1```

Call the equalizers.

```yOld = equalize(eqOld,r); yNew = eqNew(r);```

Use Linear Equalizers Considering Signal Delays

Configure `lineareq` and `comm.LinearEqualizer` objects with comparable settings. The transmit and receive filters result in a signal delay between the transit and receive signals. Account for this delay by setting the `RefTap` property of the `lineareq` to a value close to the delay value in samples. Additionally, `nWeights` must be set to a value greater than `RefTap`.

```eqOld = lineareq(filterDelay*sps+4,lms(0.01),pskmod(0:3,4,pi/4),sps); eqOld.RefTap = filterDelay*sps+1 % Adjust to synchronize with delayed signal ```
```eqOld = EqType: 'Linear Equalizer' AlgType: 'LMS' nWeights: 16 nSampPerSym: 2 RefTap: 13 SigConst: [0.7071 + 0.7071i -0.7071 + 0.7071i -0.7071 - 0.7071i 0.7071 - 0.7071i] StepSize: 0.0100 LeakageFactor: 1 Weights: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] WeightInputs: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] ResetBeforeFiltering: 1 NumSamplesProcessed: 0 ```

```eqNew = comm.LinearEqualizer('NumTaps',16,'Algorithm','LMS','StepSize',0.01, ... 'Constellation',pskmod(0:3,4,pi/4),'InputSamplesPerSymbol',sps, ... 'ReferenceTap',filterDelay*sps+1,'InputDelay',0)```
```eqNew = comm.LinearEqualizer with properties: Algorithm: 'LMS' NumTaps: 16 StepSize: 0.0100 Constellation: [0.7071 + 0.7071i -0.7071 + 0.7071i -0.7071 - 0.7071i 0.7071 - 0.7071i] ReferenceTap: 13 InputDelay: 0 InputSamplesPerSymbol: 2 TrainingFlagInputPort: false AdaptAfterTraining: true InitialWeightsSource: 'Auto' WeightUpdatePeriod: 1```

Call the equalizers. When `ResetBeforeFiltering` is set to `true`, each call of the `equalize` object resets the equalizer. To get the equivalent behavior call `reset` after each call of the `comm.LinearEqualizer` object.

```yOld1 = equalize(eqOld,r,x(1:100)); yOld2 = equalize(eqOld,r,x(1:100)); yNew1 = eqNew(r,x(1:100)); reset(eqNew) yNew2 = eqNew(r,x(1:100));```

In the `comm.LinearEqualizer` object, `InputDelay` is used to synchronize with the delayed signal. `NumTaps` and `ReferenceTap` are independent of delay value. We can reduce the number of taps by utilizing the `InputDelay` to synchronize instead of reference tap. Reducing the number of taps also reduces equalizer self noise.

```eqNew = comm.LinearEqualizer('NumTaps',11,'Algorithm','LMS','StepSize',0.01, ... 'Constellation',pskmod(0:3,4,pi/4),'InputSamplesPerSymbol',sps, ... 'ReferenceTap',6,'InputDelay',filterDelay*sps)```
```eqNew = comm.LinearEqualizer with properties: Algorithm: 'LMS' NumTaps: 11 StepSize: 0.0100 Constellation: [0.7071 + 0.7071i -0.7071 + 0.7071i -0.7071 - 0.7071i 0.7071 - 0.7071i] ReferenceTap: 6 InputDelay: 12 InputSamplesPerSymbol: 2 TrainingFlagInputPort: false AdaptAfterTraining: true InitialWeightsSource: 'Auto' WeightUpdatePeriod: 1```

```yNew1 = eqNew(r2,x(1:100)); reset(eqNew) yNew2 = eqNew(r2,x(1:100));```

## Algorithms

Referring to the schematics presented in Equalization, define w as the vector of all weights wi and define u as the vector of all inputs ui. Based on the current set of weights, w, this adaptive algorithm creates the new set of weights given by

`$\left(\text{LeakageFactor}\right)w+\frac{\left(\text{StepSize}\right){u}^{*}e}{{u}^{H}u+\text{Bias}}$`

where the * operator denotes the complex conjugate and H denotes the Hermitian transpose.

## References

[1] Farhang-Boroujeny, B., Adaptive Filters: Theory and Applications, Chichester, England, John Wiley & Sons, 1998.

## Version History

Introduced before R2006a

expand all

Errors starting in R2022a