Новичок
Профиль
Группа: Участник
Сообщений: 6
Регистрация: 10.1.2012
Репутация: нет
Всего: нет
|
Ненулевые синдромы в ссобщении не содержащем ошибок Могущестов кодов Рида-СоломонаПеред этим разобрался с алгоритмами кодирования/декодирования и написал декодер с использованием функций библиотеки Intel Performance Primitive, но теперь стоит цель написать программу без этой библиотеки. Но уже на этапе нахождения синдромов возникает проблема - ненулевые синдромы в сообщении без ошибок. Подскажите пожалуйста, что я делаю не так? Может быть проблема в том, что изначально код написан для C, а для C++ копипаст не прокатит? Что в этом случае нужно переделать? | Код |
#include "stdafx.h"
#include <iostream>
#include <ipp.h>
const int codeLength = 7; // The desired codeword length.
const int dataLength = 3; // The desired data length.
const int t = 2;
int feBitSize = 3; // Size of the field element (in bits).
int pGFSize;
int pSize;
IppStatus status;
int main(int argc, char *argv[]) {
//---------генерация сообщения----------------------//
Ipp8u pMsg[dataLength];
printf("Message:\n");
for (int i = 0; i < dataLength; i++)
{
pMsg[i] = std::rand() % codeLength;
printf("%u ", pMsg[i]);
}
printf("\n"); // получаем сообщение [6 1 6]
//----------------------SET GF---------------------------------------//
printf("GF init...\n");
status = ippsGFGetSize_8u(feBitSize, &pGFSize); // Gets the size of the IppsGFSpec_8u context in bytes.
printf("Size of IppsGFSpec_8u context = %d; ", pGFSize);
printf("%s\n", ippGetStatusString(status));
IppsGFSpec_8u* pGF = (IppsGFSpec_8u *) calloc(1, pGFSize); // Pointer to the finite field context to be initialized.
const Ipp8u pPolynomial[4] = {1, 1, 0, 1}; // Pointer to the polynomial generating the finite field.
status = ippsGFInit_8u(feBitSize, pPolynomial, pGF); // Initializes user-supplied memory as IppsGFSpec_8u context for future use.
printf("Initializes user-supplied memory... %s\n", ippGetStatusString(status));
//------------кодирование кодером IPP-------------//
int pSize = 0; // Pointer to the size of the context (in bytes).
status = ippsRSEncodeGetSize_8u(codeLength, dataLength, &pSize); // Gets the size of the ippsRSEncodeSpec_8u context in bytes.
//printf("%s\n", ippGetStatusString(status));
Ipp8u root = 1; // The root of the (first) minimal polynomial over GF.
IppsRSEncodeSpec_8u* pRS = (IppsRSEncodeSpec_8u *) malloc(pSize); // Pointer to the user-supplied buffer to be initialized as the IppsRSEncodeSpec_8u context.
status = ippsRSEncodeInit_8u(codeLength, dataLength, pGF, root, pRS); // Initializes user-supplied memory as the IppsRSEncodeSpec_8u context for future use.
//printf("%s\n", ippGetStatusString(status));
int pBufferSize = 0; // Pointer to the size of the work buffer (in bytes).
status = ippsRSEncodeGetBufferSize_8u(pRS, &pBufferSize); // Gets the size of a work buffer for the encoding operation.
//printf("%s\n", ippGetStatusString(status));
Ipp8u pCodeWord[codeLength];
Ipp8u* pBuffer=(Ipp8u *)malloc(pBufferSize);
status=ippsRSEncode_8u(pMsg, pCodeWord, pRS, pBuffer);
printf("\nCoding... %s\n", ippGetStatusString(status));
printf("Code:\n");
for (int i=0; i<codeLength; ++i)
printf("%u ", pCodeWord[i]);
printf("\n"); // код - [6 1 6 3 3 3 2]
//-------вносим ошибки---------------//
//pCodeWord[3] = 0;
//pCodeWord[6] = 0;
//pCodeWord[1] = 0;
//----------------------pow of alpha----------------------------------//
for (int i = 0; i < codeLength; i++)
{
Ipp8u alpha;
ippsGFExpAlpha_8u(i, &alpha, pGF);
printf("a^%u = %u\n", i, alpha);
}
//int p[m + 1] = {1, 0, 1, 1, 1, 0, 0, 0, 1};
int alpha_to[codeLength + 1]; // таблица степеней примитивного члена
int index_of[codeLength + 1]; // индексная таблица для быстрого умножения
//----------------------------------------------------------------------------
// генерируем look-up таблицу для быстрого умножения для GF(2 ^ m) на основе
// несократимого порождающего полинома Pc от p[0] до p[m].
//
// look-up таблица:
// index->polynomial из alpha_to[] содержит j = alpha ^ i,
// где alpha есть примитивный член, обычно равный 2
// а ^ - операция возведения в степень (не XOR!);
//
// polynomial form -> index из index_of[j = alpha ^ i] = i;
//
// c Simon Rockliff
//----------------------------------------------------------------------------
//----------------generate gf-----------------//
int mask;
mask = 1; alpha_to[feBitSize] = 0;
for (int i = 0; i < feBitSize; i++)
{
alpha_to[i] = mask;
index_of[alpha_to[i]] = i;
if (pPolynomial[i] != 0)
alpha_to[feBitSize] ^= mask;
mask <<= 1;
}
index_of[alpha_to[feBitSize]] = feBitSize; mask >>= 1;
for (int i = feBitSize + 1; i < codeLength; i++)
{
if (alpha_to[i - 1] >= mask)
alpha_to[i] = alpha_to[feBitSize] ^ ((alpha_to[i - 1] ^ mask) << 1);
else
alpha_to[i] = alpha_to[i - 1] << 1;
index_of[alpha_to[i]] = i;
}
index_of[0] = -1;
//--------------------------------------------------------------------//
//----------------------MY RS Decoder---------------------------------//
//--------------------------------------------------------------------//
printf("\nReceived message:\n");
for (int i = 0; i < codeLength; i++)
{
printf("%u ", pCodeWord[i]);
}
printf("\n");
int i, j, u, q;
int s[codeLength - dataLength + 1]; // полином синдрома ошибки
Ipp8u elp[codeLength - dataLength + 2][codeLength - dataLength]; // полином локатора ошибки лямда
Ipp8u d[codeLength - dataLength + 2];
Ipp8u l[codeLength - dataLength + 2];
Ipp8u u_lu[codeLength - dataLength + 2];
int count = 0, syn_error = 0;
//int root[t];
//int loc[t];
//int z[t + 1];
//int err[codeLength];
//int reg[t + 1];
// переводим полученное кодовое слово в индексную форму
// для упрощения вычислений
for (i = 0; i < codeLength; i++)
{
pCodeWord[i] = index_of[pCodeWord[i]];
// Ipp8u symb;
// ippsGFLogAlpha_8u(pCodeWord[i], &symb, pGF);
// pCodeWord[i] = symb;
}
// вычисляем синдром
//---------------------------------------------------------------------------
printf("\nSyndrome:\n");
for (i = 1; i <= codeLength - dataLength; i++)
{
s[i] = 0; // инициализация s-регистра
// на его вход по умолчанию поступает ноль
// выполняем s[i] += recd[j] * ij
// т.е. берем очередной символ декодируемых данных,
// умножаем его на порядковый номер данного символа,
// умноженный на номер очередного оборота и складываем
// полученный результат с содержимым s-регистра;
// по факту исчерпания всех декодируемых символ мы
// повторяем весь цикл вычислений опять - по одному
// разу для каждого символа четности
for (j = 0; j < codeLength; j++)
if (pCodeWord[j] != -1)
{
s[i] ^= alpha_to[(pCodeWord[j] + i * j) % codeLength];
//Ipp8u pwr;
//pwr = (pCodeWord[j] + i * j) % codeLength;
//Ipp8u alpha;
//ippsGFExpAlpha_8u(pwr, &alpha, pGF);
//
//s[i] ^= alpha;
}
if (s[i] != 0) syn_error = 1; // если синдром не равен нулю, взводим флаг ошибки
printf("%d ", s[i]);
// преобразуем синдром из полиномиальной формы в индексную
s[i] = index_of[s[i]];
//Ipp8u syn;
//ippsGFLogAlpha_8u(s[i], &syn, pGF);
//s[i] = syn;
}
std::cin.get();
return 0;
}
|
|
Вычисление синромов в кодах Рида-Соломона, Ненулевые синдромы в сообщении без ошибк 
Дата 30.8.2012, 14:12 (
Загрузка ...
