Выравнивание модулированных сигналов с помощью линейной фильтрации
The comm.LinearEqualizer
Система object™ использует линейную линию задержки отвода фильтра с взвешенной суммой, чтобы выровнять модулированные сигналы, переданные через дисперсионный канал. Объект эквалайзера адаптивно настраивает веса отводов на основе выбранного алгоритма. Для получения дополнительной информации см. «Алгоритмы».
Для выравнивания модулированных сигналов с помощью линейного фильтра:
Создайте comm.LinearEqualizer
Объекту и установите его свойства.
Вызывайте объект с аргументами, как будто это функция.
Дополнительные сведения о работе системных объектов см. в разделе «Что такое системные объекты?».
создает линейный эквалайзер, Системный объект для адаптивного выравнивания сигнала.lineq
= comm.LinearEqualizer
устанавливает свойства с помощью одной или нескольких пар "имя-значение". Для примера, lineq
= comm.LinearEqualizer(Name
,Value
)comm.LinearEqualizer('Algorithm','RLS')
конфигурирует объект эквалайзера для обновления весов отводов с помощью рекурсивного алгоритма наименьших квадратов (RLS). Заключайте каждое имя свойства в кавычки.
Если не указано иное, свойства являются нетронутыми, что означает, что вы не можете изменить их значения после вызова объекта. Объекты блокируются, когда вы вызываете их, и release
функция разблокирует их.
Если свойство настраивается, можно изменить его значение в любой момент.
Для получения дополнительной информации об изменении значений свойств смотрите Разработку системы в MATLAB Использование Системных объектов.
Algorithm
- Адаптивный алгоритм'LMS'
(по умолчанию) | 'RLS'
| 'CMA'
Адаптивный алгоритм, используемый для эквализации, задается как одно из следующих значений:
'LMS'
- Обновите веса отводов эквалайзера с помощью алгоритма наименьшего среднего квадрата (LMS).
'RLS'
- Обновите веса отводов эквалайзера с помощью Рекурсивного алгоритма наименьшего квадрата (RLS).
'CMA'
- Обновите веса отводов эквалайзера с помощью алгоритма постоянного модуля (CMA).
Типы данных: char
| string
NumTaps
- Количество отводов эквалайзера5
(по умолчанию) | положительное целое числоКоличество ответвлений эквалайзера, заданное как положительное целое число. Количество отводов эквалайзера должно быть больше или равно значению InputSamplesPerSymbol
свойство.
Типы данных: double
StepSize
- Размер шага0.01
(по умолчанию) | положительная скалярная величинаРазмер шага, используемый адаптивным алгоритмом, задается как положительная скалярная величина. Увеличение размера шага уменьшает время сходимости эквалайзера, но заставляет оценки выхода эквалайзера быть менее стабильными.
Совет
Чтобы определить максимально допустимый размер шага, используйте maxstep
функция объекта.
Настраиваемый: Да
Чтобы включить это свойство, установите значение Algorithm равным 'LMS'
или 'CMA'
.
Типы данных: double
ForgettingFactor
- Коэффициент забывания0.99
(по умолчанию) | скаляром в области значений (0, 1]Коэффициент забывания, используемый адаптивным алгоритмом, задается как скаляр в области значений (0, 1]. Уменьшение коэффициента забывания уменьшает время сходимости эквалайзера, но приводит к тому, что оценки выхода эквалайзера оказываются менее стабильными.
Настраиваемый: Да
Чтобы включить это свойство, установите значение Algorithm равным 'RLS'
.
Типы данных: double
InitialInverseCorrelationMatrix
- Исходная матрица обратной корреляции0.1
(по умолчанию) | скалярную матрицу |Матрица начальной обратной корреляции, заданная как скаляр или N матрица Taps-by N Taps. N Taps равно значению свойства NumTaps. Если вы задаете InitialInverseCorrelationMatrix
в качестве скаляра, a, эквалайзер устанавливает начальную матрицу обратной корреляции в a раза больше единичной матрицы: a (eye
(N Taps)).
Настраиваемый: Да
Чтобы включить это свойство, установите значение Algorithm равным 'RLS'
.
Типы данных: double
Constellation
- Сигнальное созвездиеpskmod(0:3,4,pi/4)
(по умолчанию) | векторСигнальное созвездие, заданное как вектор. Значением по умолчанию является созвездие QPSK, сгенерированное с использованием этого кода: pskmod(0:3,4,pi/4)
.
Настраиваемый: Да
Типы данных: double
ReferenceTap
- Ссылочный кран3
(по умолчанию) | положительное целое числоСсылочное касание, заданное как положительное целое число, меньше или равное значению свойства NumTaps. Эквалайзер использует положение ссылки отвода, чтобы отследить основную энергию канала.
Типы данных: double
InputDelay
- Задержка входного сигнала0
(по умолчанию) | неотрицательное целое числоЗадержка входного сигнала в выборках относительно времени сброса эквалайзера, заданная как неотрицательное целое число. Если входной сигнал является вектором длины, большей 1, то вход задержка относительно начала вектора входа. Если входной сигнал является скаляром, то входная задержка относится к первому вызову системного объекта и к первому вызову системного объекта после вызова release
или reset
функция объекта.
Типы данных: double
InputSamplesPerSymbol
- Количество входных выборок на символ1
(по умолчанию) | положительное целое числоКоличество входа отсчетов на символ, заданное в виде положительного целого числа. Установка этого свойства на любое число, больше единицы, эффективно создает фракционно разнесенный эквалайзер. Для получения дополнительной информации см. Раздел «Промежутки между символами».
Типы данных: double
AdaptAfterTraining
- Обновляйте веса касаний, когда нет обученияtrue
(по умолчанию) | false
Обновляйте веса касаний, когда нет обучения, задается как true
или false
. Если для этого свойства задано значение true
, Системный объект использует режим, ориентированный на принятие решений, чтобы обновить веса отводов эквалайзера. Если для этого свойства задано значение false
, Системный объект сохраняет веса отводов эквалайзера неизменными после обучения.
Настраиваемый: Да
Типы данных: logical
AdaptWeightsSource
- Источник запроса на адаптацию весов ответвлений'Property'
(по умолчанию) | 'Input port'
Источник запроса adapt tap weights, заданный как одно из следующих значений:
'Property'
- Задайте это значение, чтобы использовать свойство AdaptWeights для управления, когда системный объект адаптирует веса прикосновений.
'Input port'
- Задайте это значение, чтобы использовать aw
вход для управления, когда системный объект адаптирует веса касаний.
Чтобы включить это свойство, установите значение Algorithm равным 'CMA'
.
Типы данных: char
| string
AdaptWeights
- Адаптируйте веса касанийtrue
(по умолчанию) | false
Адаптируйте веса касаний, заданные как true
или false
. Если для этого свойства задано значение true
, Системный объект обновляет веса отводов эквалайзера. Если для этого свойства задано значение false
, Системный объект сохраняет веса отводов эквалайзера неизменными.
Настраиваемый: Да
Чтобы включить это свойство, установите AdaptWeightsSource на 'Property'
и установите AdaptAfterTraining на true
.
Типы данных: logical
InitialWeightsSource
- Источник для начальных весов отводов'Auto'
(по умолчанию) | 'Property'
Источник для начальных весов отвода, заданный как
'Auto'
- Инициализируйте веса прикосновений к специфичным для алгоритма значениям по умолчанию, как описано в свойстве InitialWeights.
'Property'
- Инициализируйте веса отводов с помощью значения свойства InitialWeights.
Типы данных: char
| string
InitialWeights
- Начальные веса отводов0
или [0;0;1;0;0]
(по умолчанию) | скалярный вектор | столбецНачальные веса отвода, используемые адаптивным алгоритмом, заданные в виде скаляра или вектора. Значение по умолчанию является 0
когда для свойства Algorithm задано значение 'LMS'
или 'RLS'
. Значение по умолчанию является [0;0;1;0;0]
когда для свойства Algorithm задано значение 'CMA'
.
Если вы задаете InitialWeights
как вектор, длина вектора должна быть равна значению свойства NumTaps. Если вы задаете InitialWeights
в качестве скаляра эквалайзер использует скалярное расширение, чтобы создать вектор длины NumTaps со всеми значениями, установленными на InitialWeights
.
Настраиваемый: Да
Чтобы включить это свойство, установите значение InitialWeightsSource на 'Property'
.
Типы данных: double
WeightUpdatePeriod
- Коснитесь периода обновления веса1
(по умолчанию) | положительное целое числоКоснитесь периода обновления веса в символах, заданных как положительное целое число. Эквалайзер обновляет веса отводов после обработки этого количества символов.
Типы данных: double
также задает флаг обучения y
= lineq(x
,tsym
,tf
)tf
. Обучение Системного объекта начинает, когда tf
изменения от false
на true
(на переднем ребре). Системный объект обучается до тех пор, пока все символы не будут tsym
обрабатываются. Область входа tsym
игнорируется, когда tf
является false
. Чтобы включить этот синтаксис, задайте значение свойства Algorithm 'LMS'
или 'RLS'
и свойство TrainingFlagInportPort в true
.
также задает флаг адаптирует веса y
= lineq(x
,aw
)aw
. Системный объект адаптирует веса ответвлений эквалайзера при aw
является true
. Если aw
является false
Системный объект сохраняет веса неизменными. Чтобы включить этот синтаксис, задайте значение свойства Algorithm 'CMA'
и свойство AdaptWeightsSource к 'Input port'
.
x
- Входной сигналВходной сигнал, заданный как вектор-столбец. Длина вектора входного сигнала должна быть равна целому числу, кратному значению свойства InputSamplesPerSymbol. Для получения дополнительной информации см. Раздел «Промежутки между символами».
Типы данных: double
Поддержка комплексного числа: Да
tsym
- Обучающие символыОбучающие символы, заданные как вектору-столбцу длины, меньшей или равной длине входа x
. Область входа tsym
игнорируется, когда tf
является false
.
Чтобы включить этот аргумент, задайте значение свойства Algorithm 'LMS'
или 'RLS'
.
Типы данных: double
Поддержка комплексного числа: Да
tf
- Флаг обученияtrue
| false
Флаг обучения, заданный как true
или false
. Обучение Системного объекта начинает, когда tf
изменения от false
на true
(на переднем ребре). Системный объект обучается до тех пор, пока все символы не будут tsym
обрабатываются. Область входа tsym
игнорируется, когда tf
является false
.
Чтобы включить этот аргумент, задайте значение свойства Algorithm 'LMS'
или 'RLS'
и свойство TrainingFlagInportPort в true
.
Типы данных: logical
aw
- Флаг адаптации весовtrue
| false
Адаптируйте флаг весов, заданный как true
или false
. Если aw
является true
Системный объект адаптирует веса. Если aw
является false
Системный объект сохраняет веса неизменными.
Чтобы включить этот аргумент, задайте значение свойства Algorithm 'CMA'
и свойство AdaptWeightsSource к 'Input port'
.
Типы данных: logical
y
- Выравниваемые символыУравненные символы, возвращенные как вектор-столбец, имеющий ту же длину, что и входной сигнал x.
err
- Сигнал ошибкиСигнал ошибки, возвращенный как вектор-столбец, который имеет ту же длину, что и входной сигнал x
.
weights
- Контрольные весаКоснитесь веса, возвращенные как вектор-столбец с элементами NumTaps. weights
содержит веса касаний из последнего обновления весов касаний.
Чтобы использовать функцию объекта, задайте системный объект в качестве первого входного параметра. Например, чтобы освободить системные ресурсы системного объекта с именем obj
, используйте следующий синтаксис:
release(obj)
comm.LinearEqualizer
isLocked | Определите, используется ли системный объект |
clone | Создайте повторяющийся системный объект |
info | Характеристическая информация об объекте эквалайзера |
maxstep | Максимальный размер шага для сходимости эквалайзера LMS |
mmseweights | Веса отводов линейного эквалайзера MMSE |
Создайте модулятор BPSK и систему object™ эквалайзера, задающую линейный эквалайзер LMS, имеющий восемь отводов и размер шага 0,03.
bpsk = comm.BPSKModulator; eqlms = comm.LinearEqualizer('Algorithm','LMS','NumTaps',8,'StepSize',0.03);
Измените ссылочный индекс отвода эквалайзера.
eqlms.ReferenceTap = 4;
Создайте набор тестовых данных. Получите данные путем свертки сигнала.
x = bpsk(randi([0 1],1000,1)); rxsig = conv(x,[1 0.8 0.3]);
Использование maxstep
для поиска максимально допустимого размера шага.
mxStep = maxstep(eqlms,rxsig)
mxStep = 0.1384
Выравнивание принимаемого сигнала. Используйте первые 200 символов в качестве обучающей последовательности.
y = eqlms(rxsig,x(1:200));
Примените линейную эквализацию с помощью алгоритма наименьших средних квадратов (LMS), чтобы восстановить символы QPSK, прошедшие через многолучевой канал AWGN.
Инициализируйте переменные симуляции.
M = 4; % QPSK
numSymbols = 10000;
numTrainingSymbols = 1000;
chtaps = [1 0.5*exp(1i*pi/6) 0.1*exp(-1i*pi/8)];
Сгенерируйте модулированные QPSK символы. Примените многолучевую фильтрацию каналов и искажения AWGN к символам.
data = randi([0 M-1],numSymbols,1);
tx = pskmod(data,M,pi/4);
rx = awgn(filter(chtaps,1,tx),25,'measured');
Создайте линейный эквалайзер Системного объекта и отобразите строение по умолчанию. Отрегулируйте ссылочное касание так 1
. Проверьте максимально допустимый размер шага. Выравнивание нарушенных символов.
eq = comm.LinearEqualizer
eq = comm.LinearEqualizer with properties: Algorithm: 'LMS' NumTaps: 5 StepSize: 0.0100 Constellation: [1x4 double] ReferenceTap: 3 InputDelay: 0 InputSamplesPerSymbol: 1 TrainingFlagInputPort: false AdaptAfterTraining: true InitialWeightsSource: 'Auto' WeightUpdatePeriod: 1
eq.ReferenceTap = 1; mxStep = maxstep(eq,rx)
mxStep = 0.3154
[y,err,weights] = eq(rx,tx(1:numTrainingSymbols));
Постройте график созвездия нарушенных и уравненных символов.
constell = comm.ConstellationDiagram('NumInputPorts',2);
constell(rx,y)
Постройте график сигнала ошибки эквалайзера и вычислите величину вектора ошибок (EVM) уравненных символов.
plot(abs(err)) grid on; xlabel('Symbols'); ylabel('|e|');title('Equalizer Error Signal')
errevm = comm.EVM; evm = errevm(tx,y)
evm = 11.7710
Постройте график весов отводов эквалайзера.
subplot(3,1,1); stem(real(weights)); ylabel('real(weights)'); xlabel('Tap'); grid on; axis([0 6 -0.5 1]) title('Equalizer Tap Weights') subplot(3,1,2); stem(imag(weights)); ylabel('imag(weights)'); xlabel('Tap'); grid on; axis([0 6 -0.5 1]) subplot(3,1,3); stem(abs(weights)); ylabel('abs(weights)'); xlabel('Tap'); grid on; axis([0 6 -0.5 1])
Продемонстрировать линейную эквализацию с помощью алгоритма наименьших средних квадратов (LMS), чтобы восстановить символы QPSK, прошедшие через канал AWGN. Примените различные схемы обучения эквалайзера и отобразите величину ошибки символа.
Setup системы
Симулируйте систему с QPSK-модуляцией, удовлетворяющую AWGN. Передайте пакеты, состоящие из 200 обучающих символов и 1800 случайных символов данных. Сконфигурируйте линейный эквалайзер LMS, чтобы восстановить пакетные данные.
M = 4; numTrainSymbols = 200; numDataSymbols = 1800; SNR = 20; trainingSymbols = pskmod(randi([0 M-1],numTrainSymbols,1),M,pi/4); numPkts = 10; lineq = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',5,'ReferenceTap',3,'StepSize',0.01);
Обучите эквалайзер в начале каждого пакета с сбросом
Используйте предварительно обработанные обучающие символы при обработке каждого пакета. После обработки каждого пакета сбросьте эквалайзер. Этот сброс заставляет эквалайзер обучать отводы без предыдущего знания. Сигнал ошибки эквалайзера, графиков для первого, второго и последнего пакета, показывает более высокие символьные ошибки в начале каждого пакета.
jj = 1; figure for ii = 1:numPkts b = randi([0 M-1],numDataSymbols,1); dataSym = pskmod(b,M,pi/4); packet = [trainingSymbols;dataSym]; rx = awgn(packet,SNR); [~,err] = lineq(rx,trainingSymbols); reset(lineq) if (ii ==1 || ii == 2 ||ii == numPkts) subplot(3,1,jj) plot(abs(err)) title(['Packet # ',num2str(ii)]) xlabel('Symbols') ylabel('Error Magnitude') axis([0,length(packet),0,1]) grid on; jj = jj+1; end end
Обучите эквалайзер в начале каждого пакета без сброса
Обработайте каждый пакет с помощью предварительно настроенных обучающих символов. Не сбрасывайте эквалайзер после обработки каждого пакета. Не сбрасывая после каждого пакета, эквалайзер сохраняет веса отводов от обучающих предыдущих пакетов. Сигнал ошибки эквалайзера, графиков для первого, второго и последнего пакета, показывает, что после начального обучения на первом пакете последующие пакеты имеют меньше символьных ошибок в начале каждого пакета.
release(lineq) jj = 1; figure for ii = 1:numPkts b = randi([0 M-1],numDataSymbols,1); dataSym = pskmod(b,M,pi/4); packet = [trainingSymbols;dataSym]; channel = 1; rx = awgn(packet*channel,SNR); [~,err] = lineq(rx,trainingSymbols); if (ii ==1 || ii == 2 ||ii == numPkts) subplot(3,1,jj) plot(abs(err)) title(['Packet # ',num2str(ii)]) xlabel('Symbols') ylabel('Error Magnitude') axis([0,length(packet),0,1]) grid on; jj = jj+1; end end
Периодическое обучение эквалайзера
Системы с сигналами, подверженными изменяющимся во времени каналам, требуют периодического обучения эквалайзера для поддержания блокировки изменений канала. Задайте систему, которая имеет 200 символов обучения на каждые 1800 символов данных. Между обучением эквалайзер не обновляет веса касаний. Эквалайзер обрабатывает 200 символов на пакет.
Rs = 1e6;
fd = 20;
spp = 200; % Symbols per packet
b = randi([0 M-1],numDataSymbols,1);
dataSym = pskmod(b,M,pi/4);
packet = [trainingSymbols; dataSym];
stream = repmat(packet,10,1);
tx = (0:length(stream)-1)'/Rs;
channel = exp(1i*2*pi*fd*tx);
rx = awgn(stream.*channel,SNR);
Установите AdaptAfterTraining
свойство к false
для остановки обновления веса отвода эквалайзера после фазы обучения.
release(lineq) lineq.AdaptAfterTraining = false
lineq = comm.LinearEqualizer with properties: Algorithm: 'LMS' NumTaps: 5 StepSize: 0.0100 Constellation: [1x4 double] ReferenceTap: 3 InputDelay: 0 InputSamplesPerSymbol: 1 TrainingFlagInputPort: false AdaptAfterTraining: false InitialWeightsSource: 'Auto' WeightUpdatePeriod: 1
Выравнивание нарушенных данных. Постройте график угловой ошибки из канала, сигнала ошибки эквалайзера и сигнального созвездия. Когда канал изменяется, выход эквалайзера не удаляет эффекты канала. Созвездие выхода вращается вне синхронизации, что приводит к битовым ошибкам.
[y,err] = lineq(rx,trainingSymbols); figure subplot(2,1,1) plot(tx, unwrap(angle(channel))) xlabel('Time (sec)') ylabel('Channel Angle (rad)') title('Angular Error Over Time') subplot(2,1,2) plot(abs(err)) xlabel('Symbols') ylabel('Error Magnitude') grid on title('Time-Varying Channel Without Retraining')
scatterplot(y)
Установите TrainingInputPort
свойство к true
чтобы сконфигурировать эквалайзер, чтобы переобучить отводы при сигнализации trainFlag
вход. Эквалайзер тренируется только тогда, когда trainFlag
является true
. После каждого 2000 символов эквалайзер переобучает отводы и сохраняет блокировку изменений канала. Постройте график угловой ошибки из канала, сигнала ошибки эквалайзера и сигнального созвездия. Когда канал изменяется, выход эквалайзера удаляет эффекты канала. Выходное созвездие не вращается вне синхронизации, и битовые ошибки уменьшаются.
release(lineq) lineq.TrainingFlagInputPort = true; symbolCnt = 0; numPackets = length(rx)/spp; trainFlag = true; trainingPeriod = 2000; eVec = zeros(size(rx)); yVec = zeros(size(rx)); for p=1:numPackets [yVec((p-1)*spp+1:p*spp,1),eVec((p-1)*spp+1:p*spp,1)] = ... lineq(rx((p-1)*spp+1:p*spp,1),trainingSymbols,trainFlag); symbolCnt = symbolCnt + spp; if symbolCnt >= trainingPeriod trainFlag = true; symbolCnt = 0; else trainFlag = false; end end figure subplot(2,1,1) plot(tx, unwrap(angle(channel))) xlabel('t (sec)') ylabel('Channel Angle (rad)') title('Angular Error Over Time') subplot(2,1,2) plot(abs(eVec)) xlabel('Symbols') ylabel('Error Magnitude') grid on title('Time-Varying Channel With Retraining')
scatterplot(yVec)
Симулируйте систему с задержкой между переданными символами и принятыми выборками. Типичные системы имеют фильтры передатчика и приемника, которые приводят к задержке. Эта задержка должна быть учтена для синхронизации системы. В этом примере системная задержка вводится без фильтров передачи и приема. Линейная эквализация, используя алгоритм наименьших средних квадратов (LMS), восстанавливает символы QPSK.
Инициализируйте переменные симуляции.
M = 4; % QPSK
numSymbols = 10000;
numTrainingSymbols = 1000;
mpChan = [1 0.5*exp(1i*pi/6) 0.1*exp(-1i*pi/8)];
systemDelay = dsp.Delay(20);
snr = 24;
Сгенерируйте модулированные QPSK символы. Примените многолучевую фильтрацию канала, системную задержку и AWGN к переданным символам.
data = randi([0 M-1],numSymbols,1); tx = pskmod(data,M,pi/4); % OQPSK delayedSym = systemDelay(filter(mpChan,1,tx)); rx = awgn(delayedSym,snr,'measured');
Создайте объекты equalizer и EVM System. Системный объект задает линейный эквалайзер, который использует LMS-алгоритм.
lineq = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',9,'ReferenceTap',5); evm = comm.EVM('ReferenceSignalSource', ... 'Estimated from reference constellation');
Выравнивание без корректировки входной задержки
Выравнивание полученных символов.
[y1,err1,wts1] = lineq(rx,tx(1:numTrainingSymbols,1));
Найдите задержку между принятыми символами и переданными символами с помощью finddelay
функция.
rxDelay = finddelay(tx,rx)
rxDelay = 20
Отображение информации об эквалайзере. Значение задержки указывает задержку, введенную эквалайзером. Вычислим общую задержку как сумму rxDelay
и задержку эквалайзера.
eqInfo = info(lineq)
eqInfo = struct with fields:
Latency: 4
totalDelay = rxDelay + eqInfo.Latency;
Пока выход эквалайзера не сходится, вероятность ошибки символа высока. Постройте график выхода ошибки, err1
, чтобы определить, когда выровненный выход сходится.
plot(abs(err1)) xlabel('Symbols') ylabel('Error Magnitude') title('Equalizer Error Signal')
График показывает чрезмерные ошибки после периода обучения 1000 символов. При демодуляции символов и вычислении ошибок символов, для расчета безсовпадающего вывода и системной задержки между выходом эквалайзера и переданными символами, пропустите первые 2000 символов.
dataRec1 = pskdemod(y1(2000+totalDelay:end),M,pi/4); symErrWithDelay = symerr(data(2000:end-totalDelay),dataRec1)
symErrWithDelay = 5999
evmWithDelay = evm(y1)
evmWithDelay = 29.5795
Вероятность ошибок и EVM высоки, потому что задержка приема не была учтена в Системный объект эквалайзера.
Настройте входную задержку в эквалайзере
Выравнивание полученных данных при помощи значения задержки для установки InputDelay
свойство. Потому что InputDelay
является свойством nontunable, вы должны освободить lineq
Системный объект для перенастройки InputDelay
свойство. Выравнивание полученных символов.
release(lineq) lineq.InputDelay = rxDelay
lineq = comm.LinearEqualizer with properties: Algorithm: 'LMS' NumTaps: 9 StepSize: 0.0100 Constellation: [1x4 double] ReferenceTap: 5 InputDelay: 20 InputSamplesPerSymbol: 1 TrainingFlagInputPort: false AdaptAfterTraining: true InitialWeightsSource: 'Auto' WeightUpdatePeriod: 1
[y2,err2,wts2] = lineq(rx,tx(1:numTrainingSymbols,1));
Постройте график весов отвода и выровненной величины ошибки. A диаграммы лист-ствол показывает веса отводов эквалайзера до и после удаления системной задержки. A 2D графика показывает более медленное сходимость эквалайзера для задержанного сигнала по сравнению с сигналом с удаленной задержкой.
subplot(2,1,1) stem([real(wts1),real(wts2)]) xlabel('Taps') ylabel('Tap Weight Real') legend('rxDelayed','rxDelayRemoved') grid on subplot(2,1,2) stem([imag(wts1),imag(wts2)]) xlabel('Taps') ylabel('Tap Weight Imaginary') legend('rxDelayed','rxDelayRemoved') grid on
figure plot([abs(err1),abs(err2)]) xlabel('Symbols') ylabel('Error Magnitude') legend('rxDelayed','rxDelayRemoved') grid on
Постройте выход ошибок уравненных сигналов, rxDelayed
и rxDelayRemoved
. Для сигнала, который имеет удаленную задержку, эквалайзер сходится в течение периода обучения 1000 символов. При демодуляции символов и вычислении ошибок символов, для расчета безсовпадающего вывода и системной задержки между выходом эквалайзера и переданными символами, пропустите первые 500 символов. Перенастройка эквалайзера с учетом задержки системы позволяет лучше выравнивать сигнал и уменьшает ошибки символов и EVM.
eqInfo = info(lineq)
eqInfo = struct with fields:
Latency: 4
totalDelay = rxDelay + eqInfo.Latency; dataRec2 = pskdemod(y2(500+totalDelay:end),M,pi/4); symErrDelayRemoved = symerr(data(500:end-totalDelay),dataRec2)
symErrDelayRemoved = 0
evmDelayRemoved = evm(y2(500+totalDelay:end))
evmDelayRemoved = 9.4435
Восстановите символы QPSK с помощью линейного эквалайзера с помощью обучения ответвлений на основе постоянных модулей (CMA) и EVM. При использовании алгоритмов слепого эквалайзера, таких как CMA, обучите отводы эквалайзера при помощи AdaptWeights
свойство для запуска и остановки обучения. Функции Helper используются для генерации графиков и применения фазы коррекции.
Инициализируйте системные переменные.
rng(123456); M = 4; % QPSK numSymbols = 100; numPackets = 5000; raylChan = comm.RayleighChannel('PathDelays',[0 1], ... 'AveragePathGains',[0 -12],'MaximumDopplerShift',1e-5); SNR = 50; adaptWeights = true;
Создайте объекты equalizer и EVM System. Системный объект задает линейный эквалайзер при помощи адаптивного алгоритма CMA. Вызовите функцию helper, чтобы инициализировать графики рисунков.
lineq = comm.LinearEqualizer('Algorithm','CMA', ... 'NumTaps',5,'ReferenceTap',3, ... 'StepSize',0.03,'AdaptWeightsSource','Input port')
lineq = comm.LinearEqualizer with properties: Algorithm: 'CMA' NumTaps: 5 StepSize: 0.0300 Constellation: [1x4 double] ReferenceTap: 3 InputSamplesPerSymbol: 1 AdaptWeightsSource: 'Input port' InitialWeightsSource: 'Auto' WeightUpdatePeriod: 1
info(lineq)
ans = struct with fields:
Latency: 2
evm = comm.EVM('ReferenceSignalSource', ... 'Estimated from reference constellation'); [errPlot,evmPlot,scatSym,adaptState] = initFigures(numPackets,lineq);
Эквализация Цикла
Для реализации цикла эквализации:
Сгенерируйте пакеты данных PSK.
Примените Релеевское замирание и AWGN к данным передачи.
Примените эквализацию к полученным данным и фазе коррекцию к выходу эквалайзера.
Оцените EVM и переключите adaptWeights
флаг в true
или false
на основе уровня EVM.
Обновите графики рисунков.
for p=1:numPackets data = randi([0 M-1],numSymbols,1); tx = pskmod(data,M,pi/4); rx = awgn(raylChan(tx),SNR); rxDelay = finddelay(rx,tx); [y,err,wts] = lineq(rx,adaptWeights); y = phaseCorrection(y); evmEst = evm(y); adaptWeights = (evmEst > 20); updateFigures(errPlot,evmPlot,scatSym,adaptState, ... wts,y(end),evmEst,adaptWeights,p,numPackets) end
rxDelay
rxDelay = 0
Графики рисунка показывают, что, когда EVM изменяется, эквалайзер переключается и выходит из направленного на принятие решения режима адаптации веса.
Вспомогательные функции
Эта вспомогательная функция инициализирует рисунки, которые показывают квадратичный график результатов симуляции.
function [errPlot,evmPlot,scatter,adaptState] = initFigures(numPkts,lineq) yVec = nan(numPkts,1); evmVec = nan(numPkts,1); wVec = zeros(lineq.NumTaps,1); adaptVec = nan(numPkts,1); figure subplot(2,2,1) evmPlot = stem(wVec); grid on; axis([1 lineq.NumTaps 0 1.8]) xlabel('Taps'); ylabel('|Weights|'); title('Tap Weight Magnitude') subplot(2,2,2) scatter = plot(yVec, '.'); axis square; axis([-1.2 1.2 -1.2 1.2]); grid on xlabel('In-phase'); ylabel('Quadrature'); title('Scatter Plot'); subplot(2,2,3) adaptState = plot(adaptVec); grid on; axis([0 numPkts -0.2 1.2]) ylabel('Training'); xlabel('Symbols'); title('Adapt Weights Signal') subplot(2,2,4) errPlot = plot(evmVec); grid on; axis([1 numPkts 0 100]) xlabel('Symbols'); ylabel('EVM (%)'); title('EVM') end
Эта вспомогательная функция обновляет рисунки.
function updateFigures(errPlot,evmPlot,scatSym, ... adaptState,w,y,evmEst,adaptWts,p,numFrames) persistent yVec evmVec adaptVec if p == 1 yVec = nan(numFrames,1); evmVec = nan(numFrames,1); adaptVec = nan(numFrames,1); end yVec(p) = y; evmVec(p) = evmEst; adaptVec(p) = adaptWts; errPlot.YData = abs(evmVec); evmPlot.YData = abs(w); scatSym.XData = real(yVec); scatSym.YData = imag(yVec); adaptState.YData = adaptVec; drawnow limitrate end
Эта вспомогательная функция применяет коррекцию фазы.
function y = phaseCorrection(y) a = angle(y((real(y) > 0) & (imag(y) > 0))); a(a < 0.1) = a(a < 0.1) + pi/2; theta = mean(a) - pi/4; y = y * exp(-1i*theta); end
Восстановите символы QPSK в затухающих окружениях с помощью линейного эквалайзера, используя алгоритм наименьших средних квадратов (LMS). Используйте reset
функция объекта для выравнивания независимых пакетов. Используйте вспомогательные функции для генерации графиков. Этот пример также показывает обработку на основе символов и обработку на основе кадров.
Setup
Инициализируйте системные переменные, создайте Системный объект эквалайзера и инициализируйте рисунки графика.
M = 4; % QPSK numSym = 1000; numTrainingSym = 100; numPackets = 5; numTaps = 9; ttlNumSym = numSym + numTrainingSym; raylChan = comm.RayleighChannel('PathDelays',[0 1], ... 'AveragePathGains',[0 -9], ... 'MaximumDopplerShift',0, ... 'PathGainsOutputPort',true); SNR = 35; rxVec = zeros(ttlNumSym,numPackets); txVec = zeros(ttlNumSym,numPackets); yVec = zeros(ttlNumSym,1); eVec = zeros(ttlNumSym,1); lineq1 = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',numTaps,'ReferenceTap',5, ... 'StepSize',0.01,'TrainingFlagInputPort',true); [errPlot,wStem,hStem,scatPlot] = initFigures(ttlNumSym,lineq1, ... raylChan.AveragePathGains);
Символьная обработка
Для обработки на основе символов предоставьте один символ на входе эквалайзера. Сбросьте состояние эквалайзера и канала после обработки каждого пакета.
for p = 1:numPackets trainingFlag = true; for q=1:ttlNumSym data = randi([0 M-1],1,1); tx = pskmod(data,M,pi/4); [xc,pg] = raylChan(tx); rx = awgn(xc,25); [y,err,wts] = lineq1(rx,tx,trainingFlag);
Отключите обучение после обработки numTrainingSym
обучающие символы.
if q == numTrainingSym trainingFlag = false; end updateFigures(errPlot,wStem,hStem,scatPlot,err,wts,y,pg,q,ttlNumSym); txVec(q,p) = tx; rxVec(q,p) = rx; end
После обработки каждого пакета сбрасывайте Системный объект канала, чтобы получить новую реализацию отводов канала, и Системный объект эквалайзера, чтобы восстановить набор весов отводов по умолчанию.
reset(raylChan)
reset(lineq1)
end
Пакетная обработка
Для обработки на основе пакетов предоставьте один пакет на входе эквалайзера. Каждый пакет содержит ttlNumSym
символы. Поскольку длительность обучения меньше, чем длина пакета, вам не нужно задавать вход начального обучения.
yVecPkt = zeros(ttlNumSym,numPackets); errVecPkt = zeros(ttlNumSym,numPackets); wgtVecPkt = zeros(numTaps,numPackets); lineq2 = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',9,'ReferenceTap',6,'StepSize',0.01); for p = 1:numPackets [yVecPkt(:,p),errVecPkt(:,p),wgtVecPkt(:,p)] = ... lineq2(rxVec(:,p),txVec(1:numTrainingSym,p)); for q=1:ttlNumSym updateFigures(errPlot,wStem,hStem,scatPlot, ... errVecPkt(q,p),wgtVecPkt(:,p),yVecPkt(q,p),pg,q,ttlNumSym); end
После обработки каждого пакета сбрасывайте Системный объект канала, чтобы получить новую реализацию отводов канала, и Системный объект эквалайзера, чтобы восстановить набор весов отводов по умолчанию.
reset(raylChan)
reset(lineq2)
end
Вспомогательные функции
Функция helper инициализирует рисунки.
function [errPlot,wStem,hStem,scatPlot] = initFigures(ttlNumSym,lineq,pg) yVec = nan(ttlNumSym,1); eVec = nan(ttlNumSym,1); wVec = zeros(lineq.NumTaps,1); figure; subplot(2,2,1); wStem = stem(wVec); axis([1 lineq.NumTaps 0 1.8]); grid on xlabel('Taps'); ylabel('|Weights|'); title('Tap Weight Magnitude') subplot(2,2,2); hStem = stem([0 abs(pg) 0]); grid on; xlabel('Taps'); ylabel('|Path Gain|'); title('Channel Path Gain Magnitude') subplot(2,2,3); errPlot = plot(eVec); axis([1 ttlNumSym 0 1.2]); grid on xlabel('Symbols'); ylabel('|Error Magnitude|'); title('Error Magnitude') subplot(2,2,4); scatPlot = plot(yVec,'.'); axis square; axis([-1.2 1.2 -1.2 1.2]); grid on; xlabel('In-phase'); ylabel('Quadrature'); title(sprintf('Scatter Plot')); end
Эта вспомогательная функция обновляет рисунки.
function updateFigures(errPlot,wStem,hStem,scatPlot, ... err,wts,y,pg,p,ttlNumSym) persistent yVec eVec if p == 1 yVec = nan(ttlNumSym,1); eVec = nan(ttlNumSym,1); end yVec(p) = y; eVec(p) = abs(err); errPlot.YData = abs(eVec); wStem.YData = abs(wts); hStem.YData = [0 abs(pg) 0]; scatPlot.XData = real(yVec); scatPlot.YData = imag(yVec); drawnow limitrate end
Используйте линейный эквалайзер в неадаптивном режиме. Используйте mmseweights
функция объекта, чтобы вычислить решение минимальной квадратичной невязки (MMSE) и использовать веса, возвращенные в качестве набора весов отвода для линейного эквалайзера.
Инициализируйте переменные симуляции.
M = 4; % QPSK
numSymbols = 10000;
numTrainingSymbols = 1000;
chtaps = [1 0.5*exp(1i*pi/6) 0.1*exp(-1i*pi/8)];
EbN0 = 20;
Сгенерируйте модулированные символы QPSK. Примените к символам фильтр многолучевого распространения и искажения AWGN.
data = randi([0 M-1], numSymbols, 1);
tx = pskmod(data, M, pi/4);
rx = awgn(filter(chtaps,1,tx),25,'measured');
Создайте линейный эквалайзер Системный объект, сконфигурированный для использования алгоритма CMA, установите AdaptWeights
свойство к false
, и InitialWeightsSource
свойство к Property
. Вычислите веса MMSE. Установите начальные веса отводов равными рассчитанным весам MMSE. Выравнивание нарушенных символов.
eq = comm.LinearEqualizer('Algorithm','CMA','AdaptWeights',false,'InitialWeightsSource','Property')
eq = comm.LinearEqualizer with properties: Algorithm: 'CMA' NumTaps: 5 StepSize: 0.0100 Constellation: [1x4 double] InputSamplesPerSymbol: 1 AdaptWeightsSource: 'Property' AdaptWeights: false InitialWeightsSource: 'Property' InitialWeights: [5x1 double] WeightUpdatePeriod: 1
wgts = mmseweights(eq,chtaps,EbN0)
wgts = 5×1 complex
0.0005 - 0.0068i
0.0103 + 0.0117i
0.9694 - 0.0019i
-0.3987 + 0.2186i
0.0389 - 0.1756i
eq.InitialWeights = wgts; [y,err,weights] = eq(rx);
Постройте созвездие нарушенных и уравненных символов.
constell = comm.ConstellationDiagram('NumInputPorts',2);
constell(rx,y)
Постройте график сигнала ошибки эквалайзера и вычислите величину вектора ошибок уравненных символов.
plot(abs(err)) grid on; xlabel('Symbols'); ylabel('|e|')
errevm = comm.EVM; evm = errevm(tx,y)
evm = 140.6177
Постройте график весов ответвлений эквалайзера.
subplot(3,1,1); stem(real(weights)); ylabel('real(weights)'); xlabel('Tap'); grid on; axis([1 8 -0.5 1]) line([eq.NumTaps+0.5 eq.NumTaps+0.5], [-0.5 1], 'Color', 'r', 'LineWidth', 1) title('Equalizer Tap Weights') subplot(3,1,2); stem(imag(weights)); ylabel('imag(weights)'); xlabel('Tap'); grid on; axis([1 8 -0.5 1]) line([eq.NumTaps+0.5 eq.NumTaps+0.5], [-0.5 1], 'Color', 'r', 'LineWidth', 1) subplot(3,1,3); stem(abs(weights)); ylabel('abs(weights)'); xlabel('Tap'); grid on; axis([1 8 -0.5 1]) line([eq.NumTaps+0.5 eq.NumTaps+0.5], [-0.5 1], 'Color', 'r', 'LineWidth', 1)
Продемонстрировать линейную эквализацию с помощью алгоритма наименьших средних квадратов (LMS), чтобы восстановить символы QPSK, прошедшие через канал AWGN. Обработайте дискретизацию сигнала по дискретизации.
Setup системы
Симулируйте систему с QPSK-модуляцией, удовлетворяющую AWGN. Передайте пакеты, состоящие из 200 обучающих символов и 1800 случайных символов данных. Сконфигурируйте линейный эквалайзер LMS, чтобы восстановить пакетные данные.
M = 4; numTrainSymbols = 200; numDataSymbols = 1800; SNR = 20; trainingSymbols = pskmod(randi([0 M-1],numTrainSymbols,1),M,pi/4); numPkts = 10; lineq = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',5,'ReferenceTap',3,'StepSize',0.01,'TrainingFlagInputPort',true);
Основной цикл
Используйте предварительно обработанные обучающие символы при обработке каждого пакета. После обработки каждого пакета сбросьте эквалайзер. Этот сброс заставляет эквалайзер обучать отводы без предыдущего знания. Выравнивание полученного сигнала по дискретизации. Для каждого пакета используйте первые 200 символов для обучения.
subPlotCnt = 1; figure for ii = 1:numPkts b = randi([0 M-1],numDataSymbols,1); dataSym = pskmod(b,M,pi/4); packet = [trainingSymbols;dataSym]; rx = awgn(packet,SNR); y = zeros(numDataSymbols+numTrainSymbols,1); err = zeros(numDataSymbols+numTrainSymbols,1); for jj = 1:numDataSymbols+numTrainSymbols if jj <= numTrainSymbols [y(jj),err(jj)] = lineq(rx(jj),trainingSymbols(jj),true); else [y(jj),err(jj)] = lineq(rx(jj),1i,false); end end reset(lineq) if (ii ==1 || ii == 2 ||ii == numPkts) subplot(3,1,subPlotCnt) plot(abs(err)) title(['Packet # ',num2str(ii)]) xlabel('Symbols') ylabel('Error Magnitude') axis([0,length(packet),0,1]) grid on; subPlotCnt = subPlotCnt+1; end end
Продемонстрировать линейную эквализацию с помощью алгоритма наименьших средних квадратов (LMS), чтобы восстановить символы QPSK, прошедшие через канал AWGN. Обработайте пакет, который имеет обучающие символы в начале нескольких проходов. Сравните результаты с обработкой полного пакета эквализацией за один проход.
Setup системы
Симулируйте систему с QPSK-модуляцией, удовлетворяющую AWGN. Передайте пакеты, состоящие из 200 обучающих символов и 1800 случайных символов данных. Сконфигурируйте линейный эквалайзер LMS, чтобы восстановить пакетные данные.
M = 4; numTrainSymbols = 200; numDataSymbols = 1800; SNR = 20; trainingSymbols = pskmod(randi([0 M-1],numTrainSymbols,1),M,pi/4); b = randi([0 M-1],numDataSymbols,1); dataSym = pskmod(b,M,pi/4); packet = [trainingSymbols;dataSym]; rx = awgn(packet,SNR); lineq = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',5,'ReferenceTap',3,'StepSize',0.01);
Обработка пакета за один проход
Используйте предварительно обработанные обучающие символы при обработке каждого пакета. После обработки каждого пакета сбросьте эквалайзер. Этот сброс заставляет эквалайзер обучать отводы без предыдущего знания. Выравнивание полученного сигнала по дискретизации. Для каждого пакета используйте первые 200 символов для обучения.
subPlotCnt = 1; figure [y1,err1] = lineq(rx,trainingSymbols); reset(lineq) plot(abs(err1)) title("Single Pass Processing") xlabel('Symbols') ylabel('Error Magnitude') axis([0,length(packet),0,1]) grid on;
Обработка пакета несколькими проходами
Используйте предварительно обработанные обучающие символы при обработке каждого пакета. После обработки каждого пакета сбросьте эквалайзер. Этот сброс заставляет эквалайзер обучать отводы без предыдущего знания. Выравнивание полученного сигнала по дискретизации. Для каждого пакета используйте первые 200 символов для обучения.
lineq = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',5,'ReferenceTap',3,'StepSize',0.01,'TrainingFlagInputPort',true); frameLen = 100; numFrames = (numDataSymbols+numTrainSymbols) / frameLen; figure y2 = zeros(numDataSymbols+numTrainSymbols,1); err2 = zeros(numDataSymbols+numTrainSymbols,1); idx = 1:frameLen; symbolCnt = 0; for jj = 1:numFrames if symbolCnt < numTrainSymbols [y2(idx),err2(idx)] = lineq(rx(idx),trainingSymbols(idx),true); else [y2(idx),err2(idx)] = lineq(rx(idx),1i*ones(frameLen,1),false); end idx = idx + frameLen; symbolCnt = symbolCnt + frameLen; end reset(lineq) plot(abs(err2)) title("Multipass Processing") xlabel('Symbols') ylabel('Error Magnitude') axis([0,length(packet),0,1]) grid on;
Результаты эквализации с использованием однопроходного и мультипасового подходов совпадают.
outputsEqual = isequal(y1,y2)
outputsEqual = logical
1
errorsEqual = isequal(err1,err2)
errorsEqual = logical
1
Можно сконфигурировать эквалайзер так, чтобы он работал как эквалайзер с разбиением на символы или как эквалайзер с разделением на фракции символов.
Чтобы привести эквалайзер в действие со скоростью, разнесенной по символам, задайте количество выборок на символ следующим 1
. Эквалайзеры со скоростью символов имеют отводы, разнесенные на длительность символа. Эквалайзеры со скоростью символов чувствительны к фазе синхронизации.
Чтобы управлять эквалайзером с разнесенной частотой дискретизации, задайте количество входа отсчетов на символ как целое число, больше 1
и обеспечивают входной сигнал с избыточной дискретизацией с этой частотой дискретизации. Дробные эквалайзеры с интервалами по символам имеют отводы, разнесенные на целую долю от длительности входного символа. Фракционные эквалайзеры с интервалами по символам не чувствительны к фазе синхронизации.
Линейные эквалайзеры могут удалить межсимвольную интерференцию (ISI), когда частотная характеристика канала не имеет значения null. Если в частотной характеристики канала существует ядро, линейные эквалайзеры, как правило, усиливают шум. В этом случае используйте эквалайзеры обратной связи принятия решения, чтобы избежать усиления шума.
Линейный эквалайзер состоит из выделенной линии задержки, которая сохраняет выборки из входного сигнала. Один раз за период символа эквалайзер выводит взвешенную сумму значений в линии задержки и обновляет веса для подготовки к следующему периоду символа.
Линейные эквалайзеры могут быть разнесены по символам или разделены по дробям.
Для эквалайзера с разбиением на символы количество выборок на символ, K, равно 1. Скорость выхода выборки равна скорости входа выборки.
Для эквалайзера с дробным интервалом символов количество выборок на символ, K, является целым числом, большим 1. Обычно K равен 4 для фракционно разнесенных эквалайзеров. Выходная частота дискретизации 1/ T, и входная частота дискретизации K/T, где T - период символа. Обновление веса контакта происходит со скоростью выхода.
Эта схема показывает линейный эквалайзер с L весами, периодом T и K выборками на символ. Если K равно 1, результатом является линейный эквалайзер с разбиением на символы вместо линейного эквалайзера с разделением на фракции символов.
В каждом символьном периоде эквалайзер принимает K входных выборок на выделенной линии задержки. Затем эквалайзер выводит взвешенную сумму значений в выделенной линии задержки и обновляет веса, чтобы подготовиться к следующему периоду символа.
Для получения дополнительной информации см. «Эквализация».
Для LMS-алгоритма в предыдущей схеме w является вектором всех весов wi, а u является вектором всех входов ui. На основе текущего набора весов LMS-алгоритм создает новый набор весов как
w new = w current + (StepSize) u e *.
Размер шага, используемый адаптивным алгоритмом, задается как положительная скалярная величина. Увеличение размера шага уменьшает время сходимости эквалайзера, но заставляет выравниваемый выходной сигнал быть менее стабильным. Чтобы определить максимальный размер шага, допустимый при использовании адаптивного алгоритма LMS, используйте maxstep
функция объекта. Оператор * обозначает комплексный сопряженный и вычисление ошибки e = d - y.
Для алгоритма RLS, в предыдущей схеме, w является вектором всех весов wi, и u является вектором всех входов ui. Основываясь на текущем наборе входов, u и матрице обратной корреляции, P, алгоритм RLS сначала вычисляет вектор усиления Калмана, K, как
Коэффициент забывания, используемый адаптивным алгоритмом, задается как скаляр в области значений (0, 1]. Уменьшение коэффициента забывания уменьшает время сходимости эквалайзера, но приводит к меньшей устойчивости выравниваемого выходного сигнала. H обозначает гермитову транспозицию. На основе текущей обратной корреляционной матрицы, новая обратная корреляционная матрица
На основе текущего набора весов алгоритм RLS создает новый набор весов как
w new = w current + K * e.
Оператор * обозначает комплексный сопряженный и вычисление ошибки e = d - y.
Для адаптивного алгоритма CMA, в предыдущей схеме, w является вектором всех весов wi, и u является вектором всех входов ui. Основываясь на текущем наборе весов, адаптивный алгоритм CMA создает новый набор весов как
w new = w current + (StepSize) u * e.
Размер шага, используемый адаптивным алгоритмом, задается как положительная скалярная величина. Увеличение размера шага уменьшает время сходимости эквалайзера, но заставляет выравниваемый выходной сигнал быть менее стабильным. Чтобы определить максимальный размер шага, разрешенный адаптивным алгоритмом CMA, используйте maxstep
функция объекта. Оператор * обозначает комплексный сопряженный и вычисление ошибки e = y (R - |<reservedrangesplaceholder0>|2), где R является константой, связанной с сигнальным созвездием.
У вас есть измененная версия этого примера. Вы хотите открыть этот пример с вашими правками?
1. Если смысл перевода понятен, то лучше оставьте как есть и не придирайтесь к словам, синонимам и тому подобному. О вкусах не спорим.
2. Не дополняйте перевод комментариями “от себя”. В исправлении не должно появляться дополнительных смыслов и комментариев, отсутствующих в оригинале. Такие правки не получится интегрировать в алгоритме автоматического перевода.
3. Сохраняйте структуру оригинального текста - например, не разбивайте одно предложение на два.
4. Не имеет смысла однотипное исправление перевода какого-то термина во всех предложениях. Исправляйте только в одном месте. Когда Вашу правку одобрят, это исправление будет алгоритмически распространено и на другие части документации.
5. По иным вопросам, например если надо исправить заблокированное для перевода слово, обратитесь к редакторам через форму технической поддержки.