Код Хемминга

Размещено на http://www.allbest.ru/

Оглавление

1. История создания кода Хемминга

2. Код Хемминга

3. Циклический несистематический (7,4) код Хемминга

4. Логика построения программного декодера несистематического кода

5. Декодирование

6. Логика построения программного декодера несистематического кода Хэмминга

Заключение

Список литературы

Приложение



1. История создания кода Хемминга

[1] Первая работа по теории кодирования была опубликована известным ученым Ричардом Уэсли Хэммингом в 1950 году. Привело его к этой работе следующее: после окончания университета он занимался тем, что сейчас бы назвали численными методами, и работал сначала в Лос-Аламосе над Манхэттенским проектом, то есть над созданием ядерной бомбы, а потом почти сразу, в 1946 году, перешел в Bell Labs. Это та великая лаборатория, в которой было сделано, наверное, самое большое количество открытий второй половины XX века. Там он продолжал заниматься численными методами, решать уравнения на первых вычислительных машинах.

Вычислительные машины были огромными, ненадежными, потому что на лампах, и для их охлаждения требовалось большое количество воды, и тем не менее они часто сбоили. Программисты того времени, чтобы бороться со сбоями, делили задачу на этапы, и после каждого этапа программа должна была записать или распечатать результаты. Тогда задачи были простенькие по теперешним понятиям, в основном счет.

Зачем это делалось? Так как эти компьютеры были ненадежными, у них было такое устройство, как сигнал тревоги. Когда работа шла неверно, когда они обнаруживали ошибку, то звучал сигнал тревоги, и работа прекращалась. Соответственно, человек мог с этого места посмотреть назад, какое было первое от этого места правильно посчитанное значение, и продолжать счет дальше. Хэмминг оставлял свою работу на выходные и уходил спокойно отдыхать, а приходя, обнаруживал, что машина работала впустую, потому что в некий момент происходила ошибка, но никого не было, его не было, чтобы остановить. Значит, все его труды пропадали даром. Тогда у него возникла совершенно естественная даже не идея, а вопрос: если машина умеет обнаруживать ошибки, почему бы не научить ее, чтобы она их исправляла?

Что пришло в голову Хэммингу? Он подумал, почему, собственно, проверять все значения? Может, одного проверочного символа недостаточно? Может быть, добавить не один, а два, три, четыре - столько, сколько понадобится, и исправлять?

Так и возник, наверное, самый известный код, так называемый (7,4) код Хемминга. 4 означает, что мы будем защищать от ошибок 4 бита информации, а 7 - что для этого мы к 4 информационным битам добавим 3 проверочных. Итого всего получается 7 бит.

2. Код Хемминга

[2] Код Хемминга - вероятно, наиболее известный из первых самоконтролирующихся и самокорректирующихся кодов. Построены применительно к двоичной системе счисления. Позволяет исправлять одиночную ошибку (ошибка в одном бите) и находить двойную.

Построение кодов Хэмминга основано на принципе проверки на четность числа единичных символов: к последовательности добавляется такой элемент, чтобы число единичных символов в получившейся последовательности было четным.

знак здесь означает сложение по модулю 2.

.

- ошибки нет, S = 1 однократная ошибка и т.д. Такой код называется или . Первое число - количество элементов последовательности, второе - количество информационных символов. Для каждого числа проверочных символов существует классический код Хэмминга с маркировкой:

то есть - . При иных значениях k получается так называемый усеченный код, например, международный телеграфный код МТК-2, у которого . Для него необходим код Хэмминга , который является усеченным от классического . Для Примера рассмотрим классический код Хемминга . Сгруппируем проверочные символы следующим образом:

(1)

знак здесь означает сложение по модулю 2.

Получение кодового слова выглядит следующим образом:

=

На вход декодера поступает кодовое слово

где штрихом помечены символы, которые могут исказиться в результате помехи. В декодере в режиме исправления ошибок строится последовательность синдромов:

называется синдромом последовательности.

Получение синдрома выглядит следующим образом:

V * H^T = S

=

Кодовые слова кода Хэмминга.

Таблица 1. Кодовые слова кода Хемминга (7,4)

0	0	0	0	0	0	0
0	0	0	1	0	1	1
0	0	1	0	1	1	0
0	0	1	1	1	0	1
0	1	0	0	1	1	1
0	1	0	1	1	0	0
0	1	1	0	0	0	1
0	1	1	1	0	1	0
1	0	0	0	1	0	1
1	0	0	1	1	1	0
1	0	1	0	0	1	1
1	0	1	1	0	0	0
1	1	0	0	0	1	0
1	1	0	1	0	0	1
1	1	1	0	1	0	0
1	1	1	1	1	1	1

Синдром указывает на то, что в последовательности нет искажений. Каждому ненулевому синдрому соответствует определенная конфигурация ошибок, которая исправляется на этапе декодирования. Для кода в таблице 2 указаны ненулевые синдромы и соответствующие им конфигурации ошибок (для вида: ).

Рис. 1. Схема кодера кода Хэмминга

Рис. 2. Схема декодера кода Хэмминга

Таблица 2. Синдромы и конфигурации ошибок

Синдром	001	010	011	100	101	110	111
Конфигурация ошибок	0000001	0000010	0001000	0000100	1000000	0010000	0100000
Ошибка в символе

3. Циклический несистематический (7,4) код Хемминга

Рассмотрим частный вид линейных кодов - циклический код.

Линейный код называют циклическим, если для любого кодового слова [x_n, x_0, x₁... x_n-1] циклическая перестановка символов [x₀ x₁... x_n-1 x_n] также дает кодовое слово.

Циклический несистематический (7,4) код Хемминга - двоичный циклический код, позволяющий исправлять одну ошибку и находить две.

Процедура построения таких кодов гораздо более управляемая. Однако, нам потребуется перейти от векторного описания кодов к полиномиальному. Последовательность символов основного алфавита (биты в простейшем случае), составляющие сообщения и кодовые слова мы будем интерпретировать как коэффициенты полиномов. Например, считая, что коэффициенты записаны в порядке возрастания степени, сообщение [1010] запишем в виде многочлена 1 + x². Кодирование сообщения в более "длинное" кодовое слово будет проводится умножением этого многочлена на другой, что дает в результате многочлен более высокой степени.

Введем необходимые операции в кольце Z2.

Деление. Деление в Z2 происходит, как и в обычной арифметике. Для примера рассмотрим:

(1 + x + x² + x⁵) / (1 + x²).

x⁵ + x² + x + 1

x⁵ + x³ | x² + 1 / x³ + x² + x + 1

x³ + x / x² + 1

x² + 1 / 0

Также необходимо отметить, что в кольце Z2 x + x = 0.

Замечательным свойством полиномиального представления кодов является возможность осуществить циклический сдвиг на одну позицию вправо простым умножением кодового многочлена степени n - 1 на многочлен "x" и нахождения остатка от деления на 1 + xⁿ.

Процедура кодирования в полиномиальной интерпретации сводится к умножению многочлена-сообщения на подходящий неприводимый в поле GF(2) многочлен, называемый порождающим многочленом данного кода.

Умножение. Умножение в Z₂ происходит, как и в обычной арифметике. Для примера рассмотрим:

(1 + x + x³) * (x² + x³) = x² + x⁴ + x⁵ + x⁶

Лемма 1. Многочлен g(x) является порождающим многочленом линейного циклического кода длины n тогда и только тогда, когда g(x) делит 1 + xⁿ.

Из леммы 1 следует, что для получения порождающего многочлена g(x) нам необходимо разложить на неприводимые множители 1 + xⁿ и выделить многочлен такой степени, который равен n - k. Длина кодового слова n и длина сообщения k связаны соотношением,

k = n - deg(g(x)),

где deg(g(x)) обозначает степень g(x).

В качестве делителя 1 + x⁷ выберем порождающий полином третьей степени: код хемминг программный логика

g(x) = 1 + x + x³,

тогда полученный код будет иметь длину n = 7, число проверочных символов (степень порождающего полинома) r = 3, число информационных символов k = 4, минимальное расстояние d = 3.

4. Кодирование

Закодируем сообщение [0110]. В полиноминальном виде этому сообщению соответствует многочлен:

I(x) = x + x².

Для того чтобы закодировать исходное сообщение при несистематическом кодировании информационный многочлен I(x) умножается на порождающий многочлен:

g(x) = x³ + x +1.

Полученный многочлен r(x) назовем кодовым словом.

r(x) = I(x) * g(x); r(x) = x + x³ + x⁴ + x⁵

или соответствующее кодовое слово [0101110].



Рис. 3. Схема умножения многочлена на многочлен

Листинг 1. Результат работы кодера.

for(int i = 0; i< 1; i++)

for(int j = 0; j< 7; j++)

{

bool x = 0;

for(int k = 0; k< 4; k++) // Блок программы, который выполняет

x ^= Is [i] [k]* Pm [k] [j]; // Умножение многочлена на многочлен

Ks [i] [j]= x;

}

Рис. 4. Принципиальная схема кодера несистематического кода Хэмминга: C - синхросигнал; R - активный сигнал сброса; In - информационный сигнал; Out - выход кодера

5. Декодирование

Алгоритм декодирования следующий:

1) Найти синдром или синдромный многочлен

s(x) = r(x)mod g(x),

где r(x) полученное кодовое слово.

2) Для каждого i = 0…j, вычислять

s_i(x) = xⁱs(x)mod g(x)

до тех пор, пока не будет найден, s_j такой, что для него (вес) wt(s_j) ? t, где t - максимальное число ошибок (в данной работе t = 1), исправляемых кодом. Таким образом полином ошибки есть:

e(x) = x^n-js_j(x)mod (1 + xⁿ)

Декодируем полученное сообщение [0101111]. Заметим, что седьмой бит изменен на противоположный, т.е. сообщение было принято с ошибкой. Соответствующий вектору многочлен:

r(x) = x + x³ + x⁴ + x⁵ + x⁶.

Найдем синдромный многочлен, для этого нужно найти остаток от деления многочлена r(x) на многочлен g(x).

s(x) = r(x)mod g(x); s(x) = x² + 1

Как известно, если синдром равен 0, то кодовое слово получено без искажений. В этом случае это не так.

В соответствии с описанной процедурой декодирования будем вычислять:

s_i(x) = xⁱ(x + 1)mod g(x)

для последовательных возрастающих значений i пока не найдем многочлен степени меньшей или равной одному (число ошибок t = 1).

s₁ = xs(x)mod g(x) = 1

1 имеет вес 1 для нахождения многочлена ошибок вычисляем:

e(x) = x^7-1(1)mod(xⁿ + 1) = x⁶

Итак, если отправленное кодовое слово имеет не более двух ошибок, то оно было таким:

r(x) = x + x³ + x⁴ + x⁵ + x⁶ + x⁶ = x + x³ + x⁴ + x⁵

Чтобы получить исходное слово делим кодовый многочлен r(x) на порождающий многочлен g(x).

I(x) = x + x².

Из Листинга 3 видно, что расчётные данные совпали с данными программы. Следовательно, алгоритм декодирования корректен и работает правильно.



Листинг 3. Декодер, принявший сообщение с ошибкой и исправивший ее

Также следует отметить, что если синдром будет равен 1, x или x², то полный алгоритм исправления ошибочного бита выполнять не нужно. Можно сразу сказать то, что номер ошибочного бита равен 1, 2 или 3 соответственно.

Рис. 5. Структурная схема деления многочлена на многочлен

Рис. 6. Принципиальная схема декодера несистематического кода Хэмминга

Пример. Для примера изменим 5-й бит в исходном кодовом слове. На вход декодера получаем сообщение [0101010]. Делим полученное сообщение

r(x) = x + x³ + x⁵ на g(x). s(x) = x + x².

Найдем синдромный многочлен:

1) xs(x)mod g(x) = 1 + x².

2) x²s(x)mod g(x) = 1 + x²

3) x³s(x)mod g(x) = 1

e(x) = x^7-3(1)mod(xⁿ + 1) = x⁴.

Итак, если отправленное кодовое слово имеет не более двух ошибок, то оно было таким:

r(x) = x + x³ + x⁵ + x⁴ = x + x³ + x⁴ + x⁵

Чтобы получить исходное слово делим кодовый многочлен r(x) на порождающий многочлен g(x).

I(x) = x + x².

Листинг 4. Декодер, принявший ошибку в пятом бите и исправивший ее

Из листинга 4 видно, что расчётные данные совпали с данными программы.

6. Логика построения программного декодера несистематического кода Хэмминга

Введем логику построения Декодера несистематического кода Хэмминга.

1) На вход подается кодовое слово, принятое с ошибкой или без

2) Кодовое слово делится на порождающий многочлен

3) Если остатка нет, то результат деления - информационное слово

4) Если остаток есть, то остаток есть синдром

5) С помощью синдрома блок исправления ошибок находит номер ошибочного бита

6) Ошибочный бит складывается по mod 2 с кодовым словом

7) Исправленное кодовое слово делится на порождающий многочлен

8) Результат деления есть исходное информационное слово



Заключение

Коды Хэмиинга позволяют исправлять как одиночные, так и множественные ошибки. Так как это был один из первых кодов на практике он используется все реже, но на практике они до сих пор используются для защиты памяти в компьютерах.

В данной курсовой работе, мы рассмотрели способы реализации кодера/декодера несистематического циклического кода Хэмминга в программном виде.



Список литературы

1. Материалы сайта https://ru.wikipedia.org.

2. Учеб. пособие для вузов / М.В. Гаранин, В.И. Журавлев, С.В. Кунегин. -М.: Радио и связь, 2001. - ISBN: 5-256-01475-7.

3. Феер К. Беспроводная цифровая связь. Методы модуляции и расширения спектра. Пер. с англ. - М.: Радио и связь, 2000. ISBN 5-256-01444-7.

4. Кларк Дж., мл., Кейн Дж. Кодирование с исправлением ошибок в системах цифровой связи: Пер. с англ. - М.: Радио и связь, 1987. - 392 с.

5. Теория электрической связи: Учеб. для вузов/ А.Г. Зюко, Д.Д. Кловский, В.И. Коржик, М.В. Назаров; Под ред. Д.Д. Кловского. - М: Радио и связь, 1999.



Приложение

Исходные коды. Среда разработки DevC++, язык программирования С++

#include <iostream>

using namespace std;

//Кодер несистематического

//Циклического кода Хэмминга

int main()

{

bool Ks [1] [7]= {0, 0, 0, 0, 0, 0, 0};

bool Pm [4] [7]=

{

{1, 1, 0, 1, 0, 0, 0},

{0, 1, 1, 0, 1, 0, 0},

{0, 0, 1, 1, 0, 1, 0},

{0, 0, 0, 1, 1, 0, 1}

};

bool Is [1] [4]= {0, 1, 1, 0};

cout " "Informacionnoe slovo:\n";

for(int i = 0; i< 1; i++)

for(int j = 0; j< 4; j++)

cout " Is [i] [j];

cout " endl;

for(int i = 0; i< 1; i++)

for(int j = 0; j< 7; j++)

{

bool x = 0;

for(int k = 0; k< 4; k++) // Блок программы, который выполняет

x ^= Is [i] [k]* Pm [k] [j]; // Умножение многочлена на многочлен

Ks [i] [j]= x;

}

cout " "Kodovoe slovo\n";

for(int i = 0; i< 1; i++)

for(int j = 0; j< 7; j++)

cout " Ks [i] [j];

return 0;

}

// Декодер несистематического циклического кода Хэмминга

// Исправляющий одну ошибку

using namespace std;

int main()

{

bool Ks [7]= { 0, 1, 0, 1, 1, 1, 1 };

bool Pm [7]= { 1, 1, 0, 1, 0, 0, 0 };

bool Is [4]= { 0, 0, 0, 0 };

bool Del [7]= { 0, 0, 0, 0, 0, 0, 0 };

bool Sind [7]= { 0, 0, 0, 0, 0, 0, 0 };

bool Err [7]= { 0, 0, 0, 0, 0, 0, 0 };

int k = 0;

int l = 0;

int m = 0;

int n = 0;

cout " "Kodovoe slovo, prinyatoe s oshibkoj\n";

for (int i = 0; i < 7; i++)

cout " Ks [i];

cout " endl;

// Начало деления многочлена на многочлен и определение синдрома

for (int i = 0; i < 7; i++)

{

if (Ks [i]== 1)

k = i;

}

swap(Pm [0], Pm [k]);

if (k == 4)

{ swap(Pm [2], Pm [3]); }

if (k == 5)

{ swap(Pm [1], Pm [2]); }

if (k == 6)

{

swap(Pm [3], Pm [4]);

swap(Pm [1], Pm [3]);

}

for (int i = 0; i < 7; i++)

{

Del [i]= Ks [i]- Pm [i];

}

Pm [0]= 1; Pm [1]= 1; Pm [2]= 0; Pm [3]= 1; Pm [4]= 0; Pm [5]= 0; Pm [6]= 0;

if (Del!= Pm)

{

for (int i = 0; i < 7; i++)

{

if (Del [i]== 1)

l = i;

}

if (l == 4)

{

swap(Pm [0], Pm [4]);

swap(Pm [2], Pm [3]);

}

if (l == 5)

{

swap(Pm [0], Pm [5]);

swap(Pm [1], Pm [2]);

}

if (l == 3)

{

for (int j = 0; j < 7; j++)

{

Del [j]= Del [j]- Pm [j];

if (Del [j]== 0)

{

Is [k - 3]= 1; Is [l - 3]= 1;

}

}

}

if (l < 3)

{

Sind [0]= Del [0]; Sind [1]= Sind [1]; Sind [2]= Sind [2];

}

if (l == 0)

{

Is [k - 3]= 1;

}

}

for (int i = 0; i < 7; i++)

Del [i]= Del [i]- Pm [i];

Pm [0]= 1; Pm [1]= 1; Pm [2]= 0; Pm [3]= 1; Pm [4]= 0; Pm [5]= 0; Pm [6]= 0;

if (Del!= Pm)

{

for (int i = 0; i < 7; i++)

{

if (Del [i]== 1)

m = i;

}

if (m == 4)

{

swap(Pm [0], Pm [4]);

swap(Pm [2], Pm [3]);

}

if (m == 3)

{

for (int j = 0; j < 7; j++)

{

Del [j]= Del [j]- Pm [j];

if (Del [j]== 0)

{

Is [k - 3]= 1; Is [l - 3]= 1; Is [m - 3]= 1;

}

else

{

Sind [0]= Del [0]; Sind [1]= Del [1]; Sind [2]= Del [2];

}

}

}

if (m < 3)

{

Sind [0]= Del [0]; Sind [1]= Del [1]; Sind [2]= Del [2];

}

if (m == 0)

{

Is [k - 3]= 1; Is [l - 3]= 1;

}

}

for (int i = 0; i < 7; i++)

Del [i]= Del [i]- Pm [i];

Pm [0]= 1; Pm [1]= 1; Pm [2]= 0; Pm [3]= 1; Pm [4]= 0; Pm [5]= 0; Pm [6]= 0;

if (Del!= Pm)

{

for (int i = 0; i < 7; i++)

{

if (Del [i]== 1)

n = i;

}

if (n == 3)

{

for (int j = 0; j < 7; j++)

{

Del [j]= Del [j]- Pm [j];

if (Del [j]== 0)

{

Is [k - 3]= 1; Is [l - 3]= 1; Is [m - 3]= 1; Is [n - 3];

}

else

{

Sind [0]= Del [0]; Sind [1]= Del [1]; Sind [2]= Del [2];

}

}

}

if (n < 3)

{

Sind [0]= Del [0]; Sind [1]= Del [1]; Sind [2]= Del [2];

}

}

// Конец блока деления и определения синдрома

cout " "Sindrom:\n";

for (int i = 0; i < 3; i++)

cout " Sind [i];

cout " endl;

Pm [0]= 1; Pm [1]= 1; Pm [2]= 0; Pm [3]= 1; Pm [4]= 0; Pm [5]= 0; Pm [6]= 0;

// Начало блока исправления ошибки, если она присутствует

if (Sind [0]== 1, Sind [1]== 0, Sind [2]== 0)

{ Err [0]= 1; }

else if (Sind [0]== 0, Sind [1]== 1, Sind [2]== 0)

{ Err [1]= 1; }

//if(Sind [0]== 0, Sind [1]== 0, Sind [2]== 1)

//{Err [2]= 1;}

if (Sind!= 0)

{

swap(Sind [2], Sind [3]);

swap(Sind [1], Sind [2]);

swap(Sind [0], Sind [1]);

for (int i = 0; i < 7; i++)

{

Sind [i]= Sind [i]- Pm [i];

}

for (int i = 0; i < 7; i++)

{

int count = 0;

if (Sind [i]== 1)

count++;

if (count <= 1)

{ Err [7-1]= 1; }

else

{

Pm [0]= 0; Pm [1]= 1; Pm [2]= 1; Pm [3]= 0; Pm [4]= 1; Pm [5]= 0; Pm [6]= 0;

swap(Sind [2], Sind [4]);

swap(Sind [1], Sind [3]);

swap(Sind [0], Sind [2]);

for (int i = 0; i < 7; i++)

{

Sind [i]= Sind [i]- Pm [i];

}

for (int i = 0; i < 7; i++)

{

int count = 0;

if (Sind [i]== 1)

count++;

if (count <= 1)

{ Err [7-2]= 1; }

else

{

Pm [0]= 0; Pm [1]= 0; Pm [2]= 1; Pm [3]= 1; Pm [4]= 0; Pm [5]= 1; Pm [6]= 0;

swap(Sind [2], Sind [5]);

swap(Sind [1], Sind [4]);

swap(Sind [0], Sind [3]);

for (int i = 0; i < 7; i++)

{

Sind [i]= Sind [i]- Pm [i];

}

for (int i = 0; i < 7; i++)

{

int count = 0;

if (Sind [i]== 1)

count++;

if (count <= 1)

{ Err [7-3]= 1; }

else

{

Pm [0]= 0; Pm [1]= 0; Pm [2]= 0; Pm [3]= 1; Pm [4]= 1; Pm [5]= 0; Pm [6]= 1;

swap(Sind [2], Sind [5]);

swap(Sind [1], Sind [4]);

swap(Sind [0], Sind [3]);

for (int i = 0; i < 7; i++)

{

Sind [i]= Sind [i]- Pm [i];

}

for (int i = 0; i < 7; i++)

{

int count = 0;

if (Sind [i]== 1)

count++;

if (count <= 1)

{ Err [7-4]= 1; }

}

}

}

}

}

}

}

}

// Конец блока определения ошибки

for (int i = 0; i < 7; i++)

Ks [i]= Ks [i]^ Err [i]; // Исправленное кодовое слово

cout " "Ispravlennoe kodovoe slovo:\n";

for (int i = 0; i < 7; i++)

cout " Ks [i];

cout " endl;

k = 0;

l = 0;

m = 0;

n = 0;

Del [0]= 0; Del [1]= 0; Del [2]= 0; Del [3]= 0; Del [4]= 0; Del [5]= 0; Del [6]= 0;

Pm [0]= 1; Pm [1]= 1; Pm [2]= 0; Pm [3]= 1; Pm [4]= 0; Pm [5]= 0; Pm [6]= 0;

Is [0]= 0; Is [1]= 0; Is [2]= 0; Is [3]= 0;

// Второй блок деления многочлена на многочлен

// Определение исходного информационного слова

for (int i = 0; i < 7; i++)

{

if (Ks [i]== 1)

k = i;

}

swap(Pm [0], Pm [k]);

if (k == 4)

{ swap(Pm [2], Pm [3]); }

if (k == 5)

{ swap(Pm [1], Pm [2]); }

if (k == 6)

{

swap(Pm [3], Pm [4]);

swap(Pm [1], Pm [3]);

}

for (int i = 0; i < 7; i++)

{

Del [i]= Ks [i]- Pm [i];

}

Pm [0]= 1; Pm [1]= 1; Pm [2]= 0; Pm [3]= 1; Pm [4]= 0; Pm [5]= 0; Pm [6]= 0;

if (Del!= Pm)

{

for (int i = 0; i < 7; i++)

{

if (Del [i]== 1)

l = i;

}

if (l == 4)

{

swap(Pm [0], Pm [4]);

swap(Pm [2], Pm [3]);

}

if (l == 5)

{

swap(Pm [0], Pm [5]);

swap(Pm [1], Pm [2]);

}

if (l == 3)

{

for (int j = 0; j < 7; j++)

{

Del [j]= Del [j]- Pm [j];

if (Del [j]== 0)

{

Is [k - 3]= 1; Is [l - 3]= 1;

}

}

}

}

for (int i = 0; i < 7; i++)

Del [i]= Del [i]- Pm [i];

Pm [0]= 1; Pm [1]= 1; Pm [2]= 0; Pm [3]= 1; Pm [4]= 0; Pm [5]= 0; Pm [6]= 0;

if (Del!= Pm)

{

for (int i = 0; i < 7; i++)

{

if (Del [i]== 1)

m = i;

}

if (m == 4)

{

swap(Pm [0], Pm [4]);

swap(Pm [2], Pm [3]);

}

if (m == 3)

{

for (int j = 0; j < 7; j++)

{

Del [j]= Del [j]- Pm [j];

if (Del [j]== 0)

{

Is [k - 3]= 1; Is [l - 3]= 1; Is [m - 3]= 1;

}

}

}

}

for (int i = 0; i < 7; i++)

Del [i]= Del [i]- Pm [i];

Pm [0]= 1; Pm [1]= 1; Pm [2]= 0; Pm [3]= 1; Pm [4]= 0; Pm [5]= 0; Pm [6]= 0;

if (Del!= Pm)

{

for (int i = 0; i < 7; i++)

{

if (Del [i]== 1)

n = i;

}

if (n == 3)

{

for (int j = 0; j < 7; j++)

{

Del [j]= Del [j]- Pm [j];

if (Del [j]== 0)

{

Is [k - 3]= 1; Is [l - 3]= 1; Is [m - 3]= 1; Is [n - 3];

}

}

}

}

// Конец деления многочленов

// Вывод исходного информационного слова

cout " "Informacionnoe slovo:\n";

for (int i = 0; i < 4; i++)

cout " Is [i];

}

Размещено на Allbest.ru

...