Mirror/aicodix___code
1
0
Fork 0
mirror of https://github.com/aicodix/code.git synced 2026-04-27 14:30:36 +00:00
Code Issues Projects Releases Packages Wiki Activity

Compare commits

merge into: Mirror:master
Branches Tags
Mirror:master
Mirror:work
Mirror:tail_biting
Mirror:skip_stuff
Mirror:parity_aided
Mirror:reliability
Mirror:sequence
Mirror:polar_ldpc
Mirror:ssc
Mirror:experimenting
Mirror:v1.1
Mirror:v1.0
...
pull from: Mirror:ssc
Branches Tags
Mirror:work
Mirror:tail_biting
Mirror:master
Mirror:skip_stuff
Mirror:parity_aided
Mirror:reliability
Mirror:sequence
Mirror:polar_ldpc
Mirror:ssc
Mirror:experimenting
Mirror:v1.1
Mirror:v1.0

4 commits
master ... ssc

Author SHA1 Message Date
Ahmet Inan
e3673684dd now we can get rid of leafs 2021-07-17 16:21:11 +02:00
Ahmet Inan
cdaca027dd added generic rate1() 2021-07-17 16:16:26 +02:00
Ahmet Inan
22fcdfcba0 with rep() nodes the leafs become unneccessary 2021-07-17 15:49:00 +02:00
Ahmet Inan
30b1a603b5 simplified branches where all but the last bit is frozen 2021-07-14 10:33:24 +02:00
2 changed files with 114 additions and 72 deletions
Download patch file Download diff file Expand all files Collapse all files

65
polar_decoder.hh
View file

@ -39,20 +39,15 @@ struct PolarNode
trans(*message, hard);
*message += N;
}
};
template <typename TYPE>
struct PolarNode<TYPE, 0>
static void rep(TYPE **message, TYPE *hard, TYPE *soft)
{
typedef PolarHelper<TYPE> PH;
static void rate0(TYPE *hard)
{
*hard = PH::one();
}
static void rate1(TYPE **message, TYPE *hard, TYPE *soft)
{
*hard = PH::signum(soft[1]);
*(*message)++ = *hard;
for (int h = N; h; h /= 2)
for (int i = 0; i < h/2; ++i)
soft[i+h/2] = PH::qadd(soft[i+h], soft[i+h/2+h]);
TYPE hrd = PH::signum(soft[1]);
for (int i = 0; i < N; ++i)
hard[i] = hrd;
*(*message)++ = hrd;
}
};
@ -86,6 +81,8 @@ struct PolarTree<TYPE, 6>
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
if (frozen[0] == 0xffffffff)
PolarNode<TYPE, M-1>::rate0(hard);
else if (frozen[0] == 0x7fffffff)
PolarNode<TYPE, M-1>::rep(message, hard, soft);
else if (frozen[0] == 0)
PolarNode<TYPE, M-1>::rate1(message, hard, soft);
else
@ -94,6 +91,8 @@ struct PolarTree<TYPE, 6>
soft[i+N/2] = PH::madd(hard[i], soft[i+N], soft[i+N/2+N]);
if (frozen[1] == 0xffffffff)
PolarNode<TYPE, M-1>::rate0(hard+N/2);
else if (frozen[1] == 0x7fffffff)
PolarNode<TYPE, M-1>::rep(message, hard+N/2, soft);
else if (frozen[1] == 0)
PolarNode<TYPE, M-1>::rate1(message, hard+N/2, soft);
else
@ -115,6 +114,8 @@ struct PolarTree<TYPE, 5>
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1))
PolarNode<TYPE, M-1>::rate0(hard);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<((1<<(M-1))-1))-1))
PolarNode<TYPE, M-1>::rep(message, hard, soft);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == 0)
PolarNode<TYPE, M-1>::rate1(message, hard, soft);
else
@ -123,6 +124,8 @@ struct PolarTree<TYPE, 5>
soft[i+N/2] = PH::madd(hard[i], soft[i+N], soft[i+N/2+N]);
if (frozen >> (N/2) == ((1<<(1<<(M-1)))-1))
PolarNode<TYPE, M-1>::rate0(hard+N/2);
else if (frozen >> (N/2) == ((1<<((1<<(M-1))-1))-1))
PolarNode<TYPE, M-1>::rep(message, hard+N/2, soft);
else if (frozen >> (N/2) == 0)
PolarNode<TYPE, M-1>::rate1(message, hard+N/2, soft);
else
@ -144,6 +147,8 @@ struct PolarTree<TYPE, 4>
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1))
PolarNode<TYPE, M-1>::rate0(hard);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<((1<<(M-1))-1))-1))
PolarNode<TYPE, M-1>::rep(message, hard, soft);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == 0)
PolarNode<TYPE, M-1>::rate1(message, hard, soft);
else
@ -152,6 +157,8 @@ struct PolarTree<TYPE, 4>
soft[i+N/2] = PH::madd(hard[i], soft[i+N], soft[i+N/2+N]);
if (frozen >> (N/2) == ((1<<(1<<(M-1)))-1))
PolarNode<TYPE, M-1>::rate0(hard+N/2);
else if (frozen >> (N/2) == ((1<<((1<<(M-1))-1))-1))
PolarNode<TYPE, M-1>::rep(message, hard+N/2, soft);
else if (frozen >> (N/2) == 0)
PolarNode<TYPE, M-1>::rate1(message, hard+N/2, soft);
else
@ -173,6 +180,8 @@ struct PolarTree<TYPE, 3>
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1))
PolarNode<TYPE, M-1>::rate0(hard);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<((1<<(M-1))-1))-1))
PolarNode<TYPE, M-1>::rep(message, hard, soft);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == 0)
PolarNode<TYPE, M-1>::rate1(message, hard, soft);
else
@ -181,6 +190,8 @@ struct PolarTree<TYPE, 3>
soft[i+N/2] = PH::madd(hard[i], soft[i+N], soft[i+N/2+N]);
if (frozen >> (N/2) == ((1<<(1<<(M-1)))-1))
PolarNode<TYPE, M-1>::rate0(hard+N/2);
else if (frozen >> (N/2) == ((1<<((1<<(M-1))-1))-1))
PolarNode<TYPE, M-1>::rep(message, hard+N/2, soft);
else if (frozen >> (N/2) == 0)
PolarNode<TYPE, M-1>::rate1(message, hard+N/2, soft);
else
@ -202,43 +213,27 @@ struct PolarTree<TYPE, 2>
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1))
PolarNode<TYPE, M-1>::rate0(hard);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<((1<<(M-1))-1))-1))
PolarNode<TYPE, M-1>::rep(message, hard, soft);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == 0)
PolarNode<TYPE, M-1>::rate1(message, hard, soft);
else
PolarTree<TYPE, M-1>::decode(message, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
assert(0);
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], soft[i+N], soft[i+N/2+N]);
if (frozen >> (N/2) == ((1<<(1<<(M-1)))-1))
PolarNode<TYPE, M-1>::rate0(hard+N/2);
else if (frozen >> (N/2) == ((1<<((1<<(M-1))-1))-1))
PolarNode<TYPE, M-1>::rep(message, hard+N/2, soft);
else if (frozen >> (N/2) == 0)
PolarNode<TYPE, M-1>::rate1(message, hard+N/2, soft);
else
PolarTree<TYPE, M-1>::decode(message, hard+N/2, soft, frozen >> (N/2));
assert(0);
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(hard[i], hard[i+N/2]);
}
};
template <typename TYPE>
struct PolarTree<TYPE, 1>
{
typedef PolarHelper<TYPE> PH;
static void decode(TYPE **message, TYPE *hard, TYPE *soft, uint32_t frozen)
{
soft[1] = PH::prod(soft[2], soft[3]);
if (frozen & 1)
PolarNode<TYPE, 0>::rate0(hard);
else
PolarNode<TYPE, 0>::rate1(message, hard, soft);
soft[1] = PH::madd(hard[0], soft[2], soft[3]);
if (frozen >> 1)
PolarNode<TYPE, 0>::rate0(hard+1);
else
PolarNode<TYPE, 0>::rate1(message, hard+1, soft);
hard[0] = PH::qmul(hard[0], hard[1]);
}
};
template <typename TYPE, int MAX_M>
class PolarDecoder
{

121
polar_list_decoder.hh
View file

@ -31,6 +31,48 @@ struct PolarListNode
map.v[k] = k;
return map;
}
static MAP rate1(PATH *metric, TYPE *message, MAP *maps, int *count, TYPE *hard, TYPE *soft)
{
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
MAP lmap = PolarListNode<TYPE, M-1>::rate1(metric, message, maps, count, hard, soft);
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap));
MAP rmap = PolarListNode<TYPE, M-1>::rate1(metric, message, maps, count, hard+N/2, soft);
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]);
return vshuf(lmap, rmap);
}
static MAP rep(PATH *metric, TYPE *message, MAP *maps, int *count, TYPE *hard, TYPE *soft)
{
PATH fork[2*TYPE::SIZE];
for (int k = 0; k < TYPE::SIZE; ++k)
fork[k] = fork[k+TYPE::SIZE] = metric[k];
for (int i = 0; i < N; ++i)
for (int k = 0; k < TYPE::SIZE; ++k)
if (soft[i+N].v[k] < 0)
fork[k] -= soft[i+N].v[k];
else
fork[k+TYPE::SIZE] += soft[i+N].v[k];
int perm[2*TYPE::SIZE];
for (int k = 0; k < 2*TYPE::SIZE; ++k)
perm[k] = k;
std::nth_element(perm, perm+TYPE::SIZE, perm+2*TYPE::SIZE, [fork](int a, int b){ return fork[a] < fork[b]; });
for (int k = 0; k < TYPE::SIZE; ++k)
metric[k] = fork[perm[k]];
MAP map;
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = perm[k] % TYPE::SIZE;
TYPE hrd;
for (int k = 0; k < TYPE::SIZE; ++k)
hrd.v[k] = perm[k] < TYPE::SIZE ? 1 : -1;
for (int i = 0; i < N; ++i)
hard[i] = hrd;
message[*count] = hrd;
maps[*count] = map;
++*count;
return map;
}
};
template <typename TYPE>
@ -39,17 +81,6 @@ struct PolarListNode<TYPE, 0>
typedef PolarHelper<TYPE> PH;
typedef typename PH::PATH PATH;
typedef typename PH::MAP MAP;
static MAP rate0(PATH *metric, TYPE *hard, TYPE *soft)
{
*hard = PH::one();
for (int k = 0; k < TYPE::SIZE; ++k)
if (soft[1].v[k] < 0)
metric[k] -= soft[1].v[k];
MAP map;
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
return map;
}
static MAP rate1(PATH *metric, TYPE *message, MAP *maps, int *count, TYPE *hard, TYPE *soft)
{
TYPE sft = soft[1];
@ -117,12 +148,20 @@ struct PolarListTree<TYPE, 6>
MAP lmap, rmap;
if (frozen[0] == 0xffffffff)
lmap = PolarListNode<TYPE, M-1>::rate0(metric, hard, soft);
else if (frozen[0] == 0x7fffffff)
lmap = PolarListNode<TYPE, M-1>::rep(metric, message, maps, count, hard, soft);
else if (frozen[0] == 0)
lmap = PolarListNode<TYPE, M-1>::rate1(metric, message, maps, count, hard, soft);
else
lmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard, soft, frozen[0]);
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap));
if (frozen[1] == 0xffffffff)
rmap = PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
else if (frozen[1] == 0x7fffffff)
rmap = PolarListNode<TYPE, M-1>::rep(metric, message, maps, count, hard+N/2, soft);
else if (frozen[1] == 0)
rmap = PolarListNode<TYPE, M-1>::rate1(metric, message, maps, count, hard+N/2, soft);
else
rmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard+N/2, soft, frozen[1]);
for (int i = 0; i < N/2; ++i)
@ -146,12 +185,20 @@ struct PolarListTree<TYPE, 5>
MAP lmap, rmap;
if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1))
lmap = PolarListNode<TYPE, M-1>::rate0(metric, hard, soft);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<((1<<(M-1))-1))-1))
lmap = PolarListNode<TYPE, M-1>::rep(metric, message, maps, count, hard, soft);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == 0)
lmap = PolarListNode<TYPE, M-1>::rate1(metric, message, maps, count, hard, soft);
else
lmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap));
if (frozen >> (N/2) == ((1<<(1<<(M-1)))-1))
rmap = PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
else if (frozen >> (N/2) == ((1<<((1<<(M-1))-1))-1))
rmap = PolarListNode<TYPE, M-1>::rep(metric, message, maps, count, hard+N/2, soft);
else if (frozen >> (N/2) == 0)
rmap = PolarListNode<TYPE, M-1>::rate1(metric, message, maps, count, hard+N/2, soft);
else
rmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard+N/2, soft, frozen >> (N/2));
for (int i = 0; i < N/2; ++i)
@ -175,12 +222,20 @@ struct PolarListTree<TYPE, 4>
MAP lmap, rmap;
if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1))
lmap = PolarListNode<TYPE, M-1>::rate0(metric, hard, soft);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<((1<<(M-1))-1))-1))
lmap = PolarListNode<TYPE, M-1>::rep(metric, message, maps, count, hard, soft);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == 0)
lmap = PolarListNode<TYPE, M-1>::rate1(metric, message, maps, count, hard, soft);
else
lmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap));
if (frozen >> (N/2) == ((1<<(1<<(M-1)))-1))
rmap = PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
else if (frozen >> (N/2) == ((1<<((1<<(M-1))-1))-1))
rmap = PolarListNode<TYPE, M-1>::rep(metric, message, maps, count, hard+N/2, soft);
else if (frozen >> (N/2) == 0)
rmap = PolarListNode<TYPE, M-1>::rate1(metric, message, maps, count, hard+N/2, soft);
else
rmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard+N/2, soft, frozen >> (N/2));
for (int i = 0; i < N/2; ++i)
@ -204,12 +259,20 @@ struct PolarListTree<TYPE, 3>
MAP lmap, rmap;
if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1))
lmap = PolarListNode<TYPE, M-1>::rate0(metric, hard, soft);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<((1<<(M-1))-1))-1))
lmap = PolarListNode<TYPE, M-1>::rep(metric, message, maps, count, hard, soft);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == 0)
lmap = PolarListNode<TYPE, M-1>::rate1(metric, message, maps, count, hard, soft);
else
lmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap));
if (frozen >> (N/2) == ((1<<(1<<(M-1)))-1))
rmap = PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
else if (frozen >> (N/2) == ((1<<((1<<(M-1))-1))-1))
rmap = PolarListNode<TYPE, M-1>::rep(metric, message, maps, count, hard+N/2, soft);
else if (frozen >> (N/2) == 0)
rmap = PolarListNode<TYPE, M-1>::rate1(metric, message, maps, count, hard+N/2, soft);
else
rmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard+N/2, soft, frozen >> (N/2));
for (int i = 0; i < N/2; ++i)
@ -233,44 +296,28 @@ struct PolarListTree<TYPE, 2>
MAP lmap, rmap;
if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1))
lmap = PolarListNode<TYPE, M-1>::rate0(metric, hard, soft);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<((1<<(M-1))-1))-1))
lmap = PolarListNode<TYPE, M-1>::rep(metric, message, maps, count, hard, soft);
else if ((frozen & ((1<<(1<<(M-1)))-1)) == 0)
lmap = PolarListNode<TYPE, M-1>::rate1(metric, message, maps, count, hard, soft);
else
lmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
assert(0);
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap));
if (frozen >> (N/2) == ((1<<(1<<(M-1)))-1))
rmap = PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
else if (frozen >> (N/2) == ((1<<((1<<(M-1))-1))-1))
rmap = PolarListNode<TYPE, M-1>::rep(metric, message, maps, count, hard+N/2, soft);
else if (frozen >> (N/2) == 0)
rmap = PolarListNode<TYPE, M-1>::rate1(metric, message, maps, count, hard+N/2, soft);
else
rmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard+N/2, soft, frozen >> (N/2));
assert(0);
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]);
return vshuf(lmap, rmap);
}
};
template <typename TYPE>
struct PolarListTree<TYPE, 1>
{
typedef PolarHelper<TYPE> PH;
typedef typename PH::PATH PATH;
typedef typename PH::MAP MAP;
static MAP decode(PATH *metric, TYPE *message, MAP *maps, int *count, TYPE *hard, TYPE *soft, uint32_t frozen)
{
soft[1] = PH::prod(soft[2], soft[3]);
MAP lmap, rmap;
if (frozen & 1)
lmap = PolarListNode<TYPE, 0>::rate0(metric, hard, soft);
else
lmap = PolarListNode<TYPE, 0>::rate1(metric, message, maps, count, hard, soft);
soft[1] = PH::madd(hard[0], vshuf(soft[2], lmap), vshuf(soft[3], lmap));
if (frozen >> 1)
rmap = PolarListNode<TYPE, 0>::rate0(metric, hard+1, soft);
else
rmap = PolarListNode<TYPE, 0>::rate1(metric, message, maps, count, hard+1, soft);
hard[0] = PH::qmul(vshuf(hard[0], rmap), hard[1]);
return vshuf(lmap, rmap);
}
};
template <typename TYPE, int MAX_M>
class PolarListDecoder
{