mirror of
https://github.com/aicodix/code.git
synced 2026-04-27 14:30:36 +00:00
divide and conquer decoders for K = 2 .. 6
This commit is contained in:
Ahmet Inan
parent
ae13fc7acc
commit
003d3bbd4f
1 changed files with 413 additions and 0 deletions
|
|
@ -52,5 +52,418 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
class HadamardDecoder<2>
|
||||
{
|
||||
static const int K = 2;
|
||||
static const int W = 1 << K;
|
||||
public:
|
||||
int operator()(const int8_t *code)
|
||||
{
|
||||
int tmp[2] = {
|
||||
code[0] + code[1], code[0] - code[1],
|
||||
};
|
||||
int sum[W] = {
|
||||
+ tmp[0],
|
||||
+ tmp[1],
|
||||
- tmp[0],
|
||||
- tmp[1],
|
||||
};
|
||||
int word = 0, best = 0, next = 0;
|
||||
for (int msg = 0 ; msg < W; ++msg) {
|
||||
if (sum[msg] > best) {
|
||||
next = best;
|
||||
best = sum[msg];
|
||||
word = msg;
|
||||
} else if (sum[msg] > next) {
|
||||
next = sum[msg];
|
||||
}
|
||||
}
|
||||
if (best == next)
|
||||
return -1;
|
||||
return word;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
class HadamardDecoder<3>
|
||||
{
|
||||
static const int K = 3;
|
||||
static const int W = 1 << K;
|
||||
public:
|
||||
int operator()(const int8_t *c)
|
||||
{
|
||||
int d[4] = {
|
||||
c[0] + c[1], c[0] - c[1],
|
||||
c[2] + c[3], c[2] - c[3],
|
||||
};
|
||||
int e[4] = {
|
||||
d[0] + d[2], d[0] - d[2],
|
||||
d[1] + d[3], d[1] - d[3],
|
||||
};
|
||||
int sum[W] = {
|
||||
+ e[0],
|
||||
+ e[2],
|
||||
+ e[1],
|
||||
+ e[3],
|
||||
- e[0],
|
||||
- e[2],
|
||||
- e[1],
|
||||
- e[3],
|
||||
};
|
||||
int word = 0, best = 0, next = 0;
|
||||
for (int msg = 0 ; msg < W; ++msg) {
|
||||
if (sum[msg] > best) {
|
||||
next = best;
|
||||
best = sum[msg];
|
||||
word = msg;
|
||||
} else if (sum[msg] > next) {
|
||||
next = sum[msg];
|
||||
}
|
||||
}
|
||||
if (best == next)
|
||||
return -1;
|
||||
return word;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
class HadamardDecoder<4>
|
||||
{
|
||||
static const int K = 4;
|
||||
static const int W = 1 << K;
|
||||
public:
|
||||
int operator()(const int8_t *c)
|
||||
{
|
||||
int d[8] = {
|
||||
c[0] + c[1], c[0] - c[1],
|
||||
c[2] + c[3], c[2] - c[3],
|
||||
c[4] + c[5], c[4] - c[5],
|
||||
c[6] + c[7], c[6] - c[7],
|
||||
};
|
||||
int e[8] = {
|
||||
d[0] + d[2], d[0] - d[2],
|
||||
d[1] + d[3], d[1] - d[3],
|
||||
d[4] + d[6], d[4] - d[6],
|
||||
d[5] + d[7], d[5] - d[7],
|
||||
};
|
||||
int f[8] = {
|
||||
e[0] + e[4], e[0] - e[4],
|
||||
e[1] + e[5], e[1] - e[5],
|
||||
e[2] + e[6], e[2] - e[6],
|
||||
e[3] + e[7], e[3] - e[7],
|
||||
};
|
||||
int sum[W] = {
|
||||
+ f[0],
|
||||
+ f[4],
|
||||
+ f[2],
|
||||
+ f[6],
|
||||
+ f[1],
|
||||
+ f[5],
|
||||
+ f[3],
|
||||
+ f[7],
|
||||
- f[0],
|
||||
- f[4],
|
||||
- f[2],
|
||||
- f[6],
|
||||
- f[1],
|
||||
- f[5],
|
||||
- f[3],
|
||||
- f[7],
|
||||
};
|
||||
int word = 0, best = 0, next = 0;
|
||||
for (int msg = 0 ; msg < W; ++msg) {
|
||||
if (sum[msg] > best) {
|
||||
next = best;
|
||||
best = sum[msg];
|
||||
word = msg;
|
||||
} else if (sum[msg] > next) {
|
||||
next = sum[msg];
|
||||
}
|
||||
}
|
||||
if (best == next)
|
||||
return -1;
|
||||
return word;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
class HadamardDecoder<5>
|
||||
{
|
||||
static const int K = 5;
|
||||
static const int W = 1 << K;
|
||||
public:
|
||||
int operator()(const int8_t *c)
|
||||
{
|
||||
int d[16] = {
|
||||
c[0] + c[1], c[0] - c[1],
|
||||
c[2] + c[3], c[2] - c[3],
|
||||
c[4] + c[5], c[4] - c[5],
|
||||
c[6] + c[7], c[6] - c[7],
|
||||
c[8] + c[9], c[8] - c[9],
|
||||
c[10] + c[11], c[10] - c[11],
|
||||
c[12] + c[13], c[12] - c[13],
|
||||
c[14] + c[15], c[14] - c[15],
|
||||
};
|
||||
int e[16] = {
|
||||
d[0] + d[2], d[0] - d[2],
|
||||
d[1] + d[3], d[1] - d[3],
|
||||
d[4] + d[6], d[4] - d[6],
|
||||
d[5] + d[7], d[5] - d[7],
|
||||
d[8] + d[10], d[8] - d[10],
|
||||
d[9] + d[11], d[9] - d[11],
|
||||
d[12] + d[14], d[12] - d[14],
|
||||
d[13] + d[15], d[13] - d[15],
|
||||
};
|
||||
int f[16] = {
|
||||
e[0] + e[4], e[0] - e[4],
|
||||
e[1] + e[5], e[1] - e[5],
|
||||
e[2] + e[6], e[2] - e[6],
|
||||
e[3] + e[7], e[3] - e[7],
|
||||
e[8] + e[12], e[8] - e[12],
|
||||
e[9] + e[13], e[9] - e[13],
|
||||
e[10] + e[14], e[10] - e[14],
|
||||
e[11] + e[15], e[11] - e[15],
|
||||
};
|
||||
int g[16] = {
|
||||
f[0] + f[8], f[0] - f[8],
|
||||
f[1] + f[9], f[1] - f[9],
|
||||
f[2] + f[10], f[2] - f[10],
|
||||
f[3] + f[11], f[3] - f[11],
|
||||
f[4] + f[12], f[4] - f[12],
|
||||
f[5] + f[13], f[5] - f[13],
|
||||
f[6] + f[14], f[6] - f[14],
|
||||
f[7] + f[15], f[7] - f[15],
|
||||
};
|
||||
int sum[W] = {
|
||||
+ g[0],
|
||||
+ g[8],
|
||||
+ g[4],
|
||||
+ g[12],
|
||||
+ g[2],
|
||||
+ g[10],
|
||||
+ g[6],
|
||||
+ g[14],
|
||||
+ g[1],
|
||||
+ g[9],
|
||||
+ g[5],
|
||||
+ g[13],
|
||||
+ g[3],
|
||||
+ g[11],
|
||||
+ g[7],
|
||||
+ g[15],
|
||||
- g[0],
|
||||
- g[8],
|
||||
- g[4],
|
||||
- g[12],
|
||||
- g[2],
|
||||
- g[10],
|
||||
- g[6],
|
||||
- g[14],
|
||||
- g[1],
|
||||
- g[9],
|
||||
- g[5],
|
||||
- g[13],
|
||||
- g[3],
|
||||
- g[11],
|
||||
- g[7],
|
||||
- g[15],
|
||||
};
|
||||
int word = 0, best = 0, next = 0;
|
||||
for (int msg = 0 ; msg < W; ++msg) {
|
||||
if (sum[msg] > best) {
|
||||
next = best;
|
||||
best = sum[msg];
|
||||
word = msg;
|
||||
} else if (sum[msg] > next) {
|
||||
next = sum[msg];
|
||||
}
|
||||
}
|
||||
if (best == next)
|
||||
return -1;
|
||||
return word;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
class HadamardDecoder<6>
|
||||
{
|
||||
static const int K = 6;
|
||||
static const int W = 1 << K;
|
||||
public:
|
||||
int operator()(const int8_t *c)
|
||||
{
|
||||
int d[32] = {
|
||||
c[0] + c[1], c[0] - c[1],
|
||||
c[2] + c[3], c[2] - c[3],
|
||||
c[4] + c[5], c[4] - c[5],
|
||||
c[6] + c[7], c[6] - c[7],
|
||||
c[8] + c[9], c[8] - c[9],
|
||||
c[10] + c[11], c[10] - c[11],
|
||||
c[12] + c[13], c[12] - c[13],
|
||||
c[14] + c[15], c[14] - c[15],
|
||||
c[16] + c[17], c[16] - c[17],
|
||||
c[18] + c[19], c[18] - c[19],
|
||||
c[20] + c[21], c[20] - c[21],
|
||||
c[22] + c[23], c[22] - c[23],
|
||||
c[24] + c[25], c[24] - c[25],
|
||||
c[26] + c[27], c[26] - c[27],
|
||||
c[28] + c[29], c[28] - c[29],
|
||||
c[30] + c[31], c[30] - c[31],
|
||||
};
|
||||
int e[32] = {
|
||||
d[0] + d[2], d[0] - d[2],
|
||||
d[1] + d[3], d[1] - d[3],
|
||||
d[4] + d[6], d[4] - d[6],
|
||||
d[5] + d[7], d[5] - d[7],
|
||||
d[8] + d[10], d[8] - d[10],
|
||||
d[9] + d[11], d[9] - d[11],
|
||||
d[12] + d[14], d[12] - d[14],
|
||||
d[13] + d[15], d[13] - d[15],
|
||||
d[16] + d[18], d[16] - d[18],
|
||||
d[17] + d[19], d[17] - d[19],
|
||||
d[20] + d[22], d[20] - d[22],
|
||||
d[21] + d[23], d[21] - d[23],
|
||||
d[24] + d[26], d[24] - d[26],
|
||||
d[25] + d[27], d[25] - d[27],
|
||||
d[28] + d[30], d[28] - d[30],
|
||||
d[29] + d[31], d[29] - d[31],
|
||||
};
|
||||
int f[32] = {
|
||||
e[0] + e[4], e[0] - e[4],
|
||||
e[1] + e[5], e[1] - e[5],
|
||||
e[2] + e[6], e[2] - e[6],
|
||||
e[3] + e[7], e[3] - e[7],
|
||||
e[8] + e[12], e[8] - e[12],
|
||||
e[9] + e[13], e[9] - e[13],
|
||||
e[10] + e[14], e[10] - e[14],
|
||||
e[11] + e[15], e[11] - e[15],
|
||||
e[16] + e[20], e[16] - e[20],
|
||||
e[17] + e[21], e[17] - e[21],
|
||||
e[18] + e[22], e[18] - e[22],
|
||||
e[19] + e[23], e[19] - e[23],
|
||||
e[24] + e[28], e[24] - e[28],
|
||||
e[25] + e[29], e[25] - e[29],
|
||||
e[26] + e[30], e[26] - e[30],
|
||||
e[27] + e[31], e[27] - e[31],
|
||||
};
|
||||
int g[32] = {
|
||||
f[0] + f[8], f[0] - f[8],
|
||||
f[1] + f[9], f[1] - f[9],
|
||||
f[2] + f[10], f[2] - f[10],
|
||||
f[3] + f[11], f[3] - f[11],
|
||||
f[4] + f[12], f[4] - f[12],
|
||||
f[5] + f[13], f[5] - f[13],
|
||||
f[6] + f[14], f[6] - f[14],
|
||||
f[7] + f[15], f[7] - f[15],
|
||||
f[16] + f[24], f[16] - f[24],
|
||||
f[17] + f[25], f[17] - f[25],
|
||||
f[18] + f[26], f[18] - f[26],
|
||||
f[19] + f[27], f[19] - f[27],
|
||||
f[20] + f[28], f[20] - f[28],
|
||||
f[21] + f[29], f[21] - f[29],
|
||||
f[22] + f[30], f[22] - f[30],
|
||||
f[23] + f[31], f[23] - f[31],
|
||||
};
|
||||
int h[32] = {
|
||||
g[0] + g[16], g[0] - g[16],
|
||||
g[1] + g[17], g[1] - g[17],
|
||||
g[2] + g[18], g[2] - g[18],
|
||||
g[3] + g[19], g[3] - g[19],
|
||||
g[4] + g[20], g[4] - g[20],
|
||||
g[5] + g[21], g[5] - g[21],
|
||||
g[6] + g[22], g[6] - g[22],
|
||||
g[7] + g[23], g[7] - g[23],
|
||||
g[8] + g[24], g[8] - g[24],
|
||||
g[9] + g[25], g[9] - g[25],
|
||||
g[10] + g[26], g[10] - g[26],
|
||||
g[11] + g[27], g[11] - g[27],
|
||||
g[12] + g[28], g[12] - g[28],
|
||||
g[13] + g[29], g[13] - g[29],
|
||||
g[14] + g[30], g[14] - g[30],
|
||||
g[15] + g[31], g[15] - g[31],
|
||||
};
|
||||
int sum[W] = {
|
||||
+ h[0],
|
||||
+ h[16],
|
||||
+ h[8],
|
||||
+ h[24],
|
||||
+ h[4],
|
||||
+ h[20],
|
||||
+ h[12],
|
||||
+ h[28],
|
||||
+ h[2],
|
||||
+ h[18],
|
||||
+ h[10],
|
||||
+ h[26],
|
||||
+ h[6],
|
||||
+ h[22],
|
||||
+ h[14],
|
||||
+ h[30],
|
||||
+ h[1],
|
||||
+ h[17],
|
||||
+ h[9],
|
||||
+ h[25],
|
||||
+ h[5],
|
||||
+ h[21],
|
||||
+ h[13],
|
||||
+ h[29],
|
||||
+ h[3],
|
||||
+ h[19],
|
||||
+ h[11],
|
||||
+ h[27],
|
||||
+ h[7],
|
||||
+ h[23],
|
||||
+ h[15],
|
||||
+ h[31],
|
||||
- h[0],
|
||||
- h[16],
|
||||
- h[8],
|
||||
- h[24],
|
||||
- h[4],
|
||||
- h[20],
|
||||
- h[12],
|
||||
- h[28],
|
||||
- h[2],
|
||||
- h[18],
|
||||
- h[10],
|
||||
- h[26],
|
||||
- h[6],
|
||||
- h[22],
|
||||
- h[14],
|
||||
- h[30],
|
||||
- h[1],
|
||||
- h[17],
|
||||
- h[9],
|
||||
- h[25],
|
||||
- h[5],
|
||||
- h[21],
|
||||
- h[13],
|
||||
- h[29],
|
||||
- h[3],
|
||||
- h[19],
|
||||
- h[11],
|
||||
- h[27],
|
||||
- h[7],
|
||||
- h[23],
|
||||
- h[15],
|
||||
- h[31],
|
||||
};
|
||||
int word = 0, best = 0, next = 0;
|
||||
for (int msg = 0 ; msg < W; ++msg) {
|
||||
if (sum[msg] > best) {
|
||||
next = best;
|
||||
best = sum[msg];
|
||||
word = msg;
|
||||
} else if (sum[msg] > next) {
|
||||
next = sum[msg];
|
||||
}
|
||||
}
|
||||
if (best == next)
|
||||
return -1;
|
||||
return word;
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue