Documentation

This is machine translation

Mouseover text to see original. Click the button below to return to the English version of the page.

cma

(To be removed) Construct constant modulus algorithm (CMA) object

cma will be removed in a future release. Use `comm.LinearEqualizer` or `comm.DecisionFeedback` instead.

Syntax

```alg = cma(stepsize) alg = cma(stepsize,leakagefactor) ```

Description

The `cma` 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.

Note

After you use either `lineareq` or `dfe` to create a CMA equalizer object, you should initialize the equalizer object's `Weights` property with a nonzero vector. Typically, CMA is used with differential modulation; otherwise, the initial weights are very important. A typical vector of initial weights has a 1 corresponding to the center tap and 0s elsewhere.

`alg = cma(stepsize)` constructs an adaptive algorithm object based on the constant modulus algorithm (CMA) with a step size of `stepsize`.

`alg = cma(stepsize,leakagefactor)` sets the leakage factor of the CMA. `leakagefactor` must be 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.

Properties

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

PropertyDescription
`AlgType`Fixed value, `'Constant Modulus'`
`StepSize`CMA step size parameter, a nonnegative real number
`LeakageFactor`CMA leakage factor, a real number between 0 and 1

Examples

collapse all

Use the constant modulus algorithm (CMA) to create an adaptive equalizer object.

Set the number of weights and the step size for the equalizer.

```nWeights = 1; stepSize = 0.1;```

Create an adaptive algorithm object using the `cma` function.

`alg = cma(stepSize);`

Construct a linear equalizer using the algorithm object.

`eqObj = lineareq(nWeights,alg)`
```eqObj = EqType: 'Linear Equalizer' AlgType: 'Constant Modulus' nWeights: 1 nSampPerSym: 1 SigConst: [-1 1] StepSize: 0.1000 LeakageFactor: 1 Weights: 0 WeightInputs: 0 ResetBeforeFiltering: 1 NumSamplesProcessed: 0 ```

Algorithms

Referring to the schematics 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

(`LeakageFactor`) w + (`StepSize`) u*e

where the * operator denotes the complex conjugate.

Compatibility Considerations

expand all

Not recommended starting in R2019a

References

 Haykin, Simon, Adaptive Filter Theory, Third Ed., Upper Saddle River, NJ, Prentice-Hall, 1996.

 Johnson, Richard C., Jr., Philip Schniter, Thomas. J. Endres, et al., “Blind Equalization Using the Constant Modulus Criterion: A Review,” Proceedings of the IEEE, Vol. 86, October 1998, pp. 1927–1950.