итеративный код

[kiv]

может кто объяснит мне алгоритм инеративного кода, не совсем понимаю.

Сформировать сообщение, состоящее из 16 символов, каждый символ сообщения представляется 8 битами.Представить сообщение в виде битового массива {ai}....
Осуществить кодирование зашифрованного сообщения путем разбиения его на сегменты по 16 бит и последующего кодирования элементарных сегментов итеративным кодом.

Примечание: Кодирование сообщения Х из 4 бит итеративным кодом осуществляется путем записи его в виде квадрата:
X0   X1   X2   X3  | A1
X4   X5   X6   X7  | A2
X8   X9   X10  X11 | A3
X12  X13  X14  X15 | A4
-  - -- - -- - - - -
Z1   Z2   Z3   Z4  |
 
и добавлению символов Ai, представляющих собой сумму элементов по i-ой строке по модулю 2, и символов Zj, представляющих собой сумму элементов по j-му столбцу по модулю 2.

начальное сообщение сделала одномерным массивом, есть ли смысл его переделывать в двумерный 4*32?( хотя как это сделать незнаю.))))
правильно я понимаю, что нужно сложить все элементы А1 и Z1, а потом их между собой, в итоге из 16 бит получится 4....а декодирование 

Операция декодирования осуществляется следующим образом. Сегмент информационного массива на выходе канала связи длиной 24 бита расположить в форме массива, используемого при операции кодирования. Сформировать массивы Ai и Zj. Если Zi = 1 и Aj = 1, тогда элемент, находящийся на пересечении j-ой строки и i-го столбца инвертируется.

как че формировать черт знает...почему 24 бита, а не 32(128 всего бит/16 в таблице =8 раз кодируем, в результате получаем 4 бита: 8*4=32 )

[Алексей++]

не совсем понятно, что имеется в виду под "и добавлению символов Ai, .... и символов Zj" - что куда и как добавляется ?

или делается просто 0x1234 - > AiZi (1 байт ? )

никаких массивов переделывать тут не нужно - всё на лету делается

Код:

//вспомогательная структура для "разбора" битов
struct s_AZ_bits
{
	union
	{
		WORD wnum;

		struct
		{
			WORD A1 : 4;
			WORD A2 : 4;
			WORD A3 : 4;
			WORD A4 : 4;
		};

		struct
		{
			WORD Z1_0 : 1;
			WORD Z2_0 : 1;
			WORD Z3_0 : 1;
			WORD Z4_0 : 1;
			WORD Z1_1 : 1;
			WORD Z2_1 : 1;
			WORD Z3_1 : 1;
			WORD Z4_1 : 1;
			WORD Z1_2 : 1;
			WORD Z2_2 : 1;
			WORD Z3_2 : 1;
			WORD Z4_2 : 1;
			WORD Z1_3 : 1;
			WORD Z2_3 : 1;
			WORD Z3_3 : 1;
			WORD Z4_3 : 1;
		};
	};

	inline BYTE GetA1(){return A1;}
	inline BYTE GetA2(){return A2;}
	inline BYTE GetA3(){return A3;}
	inline BYTE GetA4(){return A4;}
	inline BYTE GetZ1(){return (Z1_0|(Z1_1<<1)|(Z1_2<<2)|(Z1_3<<3));}
	inline BYTE GetZ2(){return (Z2_0|(Z2_1<<1)|(Z2_2<<2)|(Z2_3<<3));}
	inline BYTE GetZ3(){return (Z3_0|(Z3_1<<1)|(Z3_2<<2)|(Z3_3<<3));}
	inline BYTE GetZ4(){return (Z4_0|(Z4_1<<1)|(Z4_2<<2)|(Z4_3<<3));}
};

BYTE message[16]={0};
DWORD dwdLen=sizeof(message);

s_AZ_bits bits;

for(DWORD i=0; i+1<dwdLen; i+=2)
{
	bits.wnum=*(WORD*)&message[i];

	//тут что надо делаешь с числами A и Z
	...=bits.GetA1();
	...=bits.GetA2();
	...=bits.GetA3();
	...=bits.GetA4();
	...=bits.GetZ1();
	...=bits.GetZ2();
	...=bits.GetZ3();
	...=bits.GetZ4();
}

[Sla]

все элементарно
первые четыре бита складываются по модулю 2  получаем А1
следующие четыре - А2
таким образом получаем четыре контрольных бита А(i)

каждый четвертый бит суммируется по модулю 2 получаем биты Z(j)
таким образом:
16 бит информационных + 4 проверочных А(i) + 4 проверочных Z(j)

[Алексей++]

тогда структура разбора перепишем так

Код:

struct s_AZ_bits
{
	union
	{
		WORD wnum;

		struct
		{
			WORD A1_0 : 1;
			WORD A2_1 : 1;
			WORD A3_2 : 1;
			WORD A4_3 : 1;
			WORD A1_0 : 1;
			WORD A2_1 : 1;
			WORD A3_2 : 1;
			WORD A4_3 : 1;
			WORD A1_0 : 1;
			WORD A2_1 : 1;
			WORD A3_2 : 1;
			WORD A4_3 : 1;
			WORD A1_0 : 1;
			WORD A2_1 : 1;
			WORD A3_2 : 1;
			WORD A4_3 : 1;
		};

		struct
		{
			WORD Z1_0 : 1;
			WORD Z2_0 : 1;
			WORD Z3_0 : 1;
			WORD Z4_0 : 1;
			WORD Z1_1 : 1;
			WORD Z2_1 : 1;
			WORD Z3_1 : 1;
			WORD Z4_1 : 1;
			WORD Z1_2 : 1;
			WORD Z2_2 : 1;
			WORD Z3_2 : 1;
			WORD Z4_2 : 1;
			WORD Z1_3 : 1;
			WORD Z2_3 : 1;
			WORD Z3_3 : 1;
			WORD Z4_3 : 1;
		};
	};

	inline BYTE GetA1(){return (A1_0 + A1_1 + A1_2 + A1_3)&1;}
	inline BYTE GetA2(){return (A2_0 + A1_2 + A2_2 + A2_3)&1;}
	inline BYTE GetA3(){return (A3_0 + A1_3 + A3_2 + A3_3)&1;}
	inline BYTE GetA4(){return (A4_0 + A1_4 + A4_2 + A4_3)&1;}
	inline BYTE GetZ1(){return (Z1_0 + Z1_1 + Z1_2 + Z1_3)&1;}
	inline BYTE GetZ2(){return (Z2_0 + Z1_2 + Z2_2 + Z2_3)&1;}
	inline BYTE GetZ3(){return (Z3_0 + Z1_3 + Z3_2 + Z3_3)&1;}
	inline BYTE GetZ4(){return (Z4_0 + Z1_4 + Z4_2 + Z4_3)&1;}
};

[kiv]

(A1_0 + A1_1 + A1_2 + A1_3)&1; - почему?
разве не так по модулю 2:
A1_0 ^ A1_1^ A1_2 ^ A1_3

[Алексей++]

надо же сложение по модулю 2, а не побитовое умножение

[kiv]

http://ru.wikipedia.org/wiki/%D0%A1%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%BE_%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8E_2
на с++ пишу

[Алексей++]

ну а что не так то ?

[Вад]

надо же сложение по модулю 2, а не побитовое умножение

А где тут умножение? Умножение - это & (1&1 = 1, в остальных случаях 0). ^ - это как раз эквивалент сложения по модулю 2: (1^1)=(0^0)=0;  (1^0)=(0^1)=1

[Алексей++]

Вад,

Сложение по модулю 2 (исключа́ющее «ИЛИ», XOR, «сумма по модулю 2»)

ксор работает так:

0 xor 0 == 0
1 xor 0 == 1
0 xor 1 == 1
1 xor 1 == 0

0 xor 0 xor 0 == 0
0 xor 0 xor 1 == 1
0 xor 1 xor 0 == 1
0 xor 1 xor 1 == 0
1 xor 0 xor 0 == 1
1 xor 0 xor 1 == 0
1 xor 1 xor 0 == 0
1 xor 1 xor 1 == 1

то есть, это будет всё равно, что сложить арифметически все значения и взять младший бит результата

[Вад]

Алексей1153++, именно это я и хотел сказать

[Алексей++]

Вад, ну, считаем, что убедили Вику )))

[kiv]

че я не так сделала? не правильно считает...

Код:

int q,x;
unsigned char a[24]={0},z[24]={0};
for(i=0;i<128;i+=16)
{  for( x=0;x<16;x+=4)
   {  for( q=0;q<4;q++) {
   a[q] = bits[x]^bits[x+1]^bits[x+2]^bits[x+3];
 z[q]= bits[q]^bits[q+4]^bits[q+8]^bits[q+12];

   }

   }

}
for(x=0;x<24;x++)
{   cout<<(int)a[x]<<" ";
}
  cout<<endl;
 for(x=0;x<24;x++)
{   cout<<(int)z[x]<<" ";
}
  cout<<endl;

[Вад]

Код:

for(x=0;x<24;x++)
{   cout<<(int)a[x]<<" ";
}
  cout<<endl;
 for(x=0;x<24;x++)
{   cout<<(int)z[x]<<" ";
}
  cout<<endl;

это ещё почему 24? вроде, a и z имеют размерность 4. И смысл цикла for( x=0;x<16;x+=4) объясни заодно

[kiv]

ну так это 4 у одной таблицы из 16 битов, а таких 8 получится, ведь в сообщении 16 символов, ну там не 24 по идеи, а 32...ну смысл- берем блок из 16 бит, потом в нем из 4х...а как без него?

[Вад]

А зачем считать все таблицы сразу? Одной же хватит. У а и z по 4 элемента - так в схеме нарисовано. Считаешь a1..a4, z1..z4. Потом прибавляешь к элементам X0..x15 то и другое, согласно инструкции.

[kiv]

вроде сделала.....

Код:

for(k=0;k<128;k+=16)
 for(int i=0;i<4;++i) 
 {
     a[i]=0;
     z[i]=0;
 
     for(int j=0;j<4;++j)
     {
       a[i]^=bits2[k+i*4+j];
       z[i]^=bits2[k+j*4+i];
     }
 }

как теперь это прибавить к тому что есть....

[Алексей++]

Offtopic:

я не совсем уловил - это уже какое то другое задание началось ? )

Поставлю в угол.

[Вад]

Алексей1153++, да нет, как будто. Это подсчёт A и Z для таблицы

kiv, Ну так берёшь на вход блок из 16 бит. Вычисляешь A и Z, затем складываешь символы с A[i] и Z[j], как положено, и записываешь в результирующий блок. Я только не понял, нужно ли в результат записывать 8 бит из A и Z (в конец блока).

[Алексей++]

а зачем тогда столько мучений, когда структура битовых полей для разбора битов куда удобнее и быстрее работает ? )

если сложение сильно не устраивает, то так

inline BYTE GetA1(){return A1_0^A1_1^A1_2^A1_3;}

[kiv]

как эту фигню раскодировать?
массив mas[24*8], в нем сначала 16 бит сообщения, потом а1,z1, a2, z2... записаны.

[Sla]

а зачем?
они не закодированы, они защищены.

[kiv]

в смысле? задание такое...

[Вад]

kiv, надо полагать, нужно опять прибавить к элементу ai и zj.