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

use uint32_t for the frozen bits

Browse source
This commit is contained in:
Ahmet Inan 2021-07-12 19:11:15 +02:00
commit 631ec8beef
6 changed files with 312 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

127
polar_decoder.hh
View file

@ -16,26 +16,135 @@ struct PolarTree
{
typedef PolarHelper<TYPE> PH;
static const int N = 1 << M;
static void decode(TYPE **message, TYPE *hard, TYPE *soft, const uint8_t *frozen)
static void decode(TYPE **message, TYPE *hard, TYPE *soft, const uint32_t *frozen)
{
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
PolarTree<TYPE, M-1>::decode(message, hard, soft, frozen);
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], soft[i+N], soft[i+N/2+N]);
PolarTree<TYPE, M-1>::decode(message, hard+N/2, soft, frozen+N/2);
PolarTree<TYPE, M-1>::decode(message, hard+N/2, soft, frozen+N/2/32);
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(hard[i], hard[i+N/2]);
}
};
template <typename TYPE>
struct PolarTree<TYPE, 6>
{
typedef PolarHelper<TYPE> PH;
static const int M = 6;
static const int N = 1 << M;
static void decode(TYPE **message, TYPE *hard, TYPE *soft, const uint32_t *frozen)
{
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
PolarTree<TYPE, M-1>::decode(message, hard, soft, frozen[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]);
PolarTree<TYPE, M-1>::decode(message, hard+N/2, soft, frozen[1]);
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(hard[i], hard[i+N/2]);
}
};
template <typename TYPE>
struct PolarTree<TYPE, 5>
{
typedef PolarHelper<TYPE> PH;
static const int M = 5;
static const int N = 1 << M;
static void decode(TYPE **message, TYPE *hard, TYPE *soft, uint32_t frozen)
{
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
PolarTree<TYPE, M-1>::decode(message, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], soft[i+N], soft[i+N/2+N]);
PolarTree<TYPE, M-1>::decode(message, hard+N/2, soft, frozen >> (N/2));
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(hard[i], hard[i+N/2]);
}
};
template <typename TYPE>
struct PolarTree<TYPE, 4>
{
typedef PolarHelper<TYPE> PH;
static const int M = 4;
static const int N = 1 << M;
static void decode(TYPE **message, TYPE *hard, TYPE *soft, uint32_t frozen)
{
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
PolarTree<TYPE, M-1>::decode(message, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], soft[i+N], soft[i+N/2+N]);
PolarTree<TYPE, M-1>::decode(message, hard+N/2, soft, frozen >> (N/2));
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(hard[i], hard[i+N/2]);
}
};
template <typename TYPE>
struct PolarTree<TYPE, 3>
{
typedef PolarHelper<TYPE> PH;
static const int M = 3;
static const int N = 1 << M;
static void decode(TYPE **message, TYPE *hard, TYPE *soft, uint32_t frozen)
{
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
PolarTree<TYPE, M-1>::decode(message, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], soft[i+N], soft[i+N/2+N]);
PolarTree<TYPE, M-1>::decode(message, hard+N/2, soft, frozen >> (N/2));
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(hard[i], hard[i+N/2]);
}
};
template <typename TYPE>
struct PolarTree<TYPE, 2>
{
typedef PolarHelper<TYPE> PH;
static const int M = 2;
static const int N = 1 << M;
static void decode(TYPE **message, TYPE *hard, TYPE *soft, uint32_t frozen)
{
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
PolarTree<TYPE, M-1>::decode(message, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], soft[i+N], soft[i+N/2+N]);
PolarTree<TYPE, M-1>::decode(message, hard+N/2, soft, frozen >> (N/2));
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]);
PolarTree<TYPE, 0>::decode(message, hard, soft, frozen & 1);
soft[1] = PH::madd(hard[0], soft[2], soft[3]);
PolarTree<TYPE, 0>::decode(message, hard+1, soft, frozen >> 1);
hard[0] = PH::qmul(hard[0], hard[1]);
}
};
template <typename TYPE>
struct PolarTree<TYPE, 0>
{
typedef PolarHelper<TYPE> PH;
static void decode(TYPE **message, TYPE *hard, TYPE *soft, const uint8_t *frozen)
static void decode(TYPE **message, TYPE *hard, TYPE *soft, uint32_t frozen)
{
if (*frozen) {
if (frozen) {
*hard = PH::one();
} else {
*hard = PH::signum(soft[1]);
@ -47,12 +156,13 @@ struct PolarTree<TYPE, 0>
template <typename TYPE, int MAX_M>
class PolarDecoder
{
static_assert(MAX_M >= 5 && MAX_M <= 29);
typedef PolarHelper<TYPE> PH;
static const int MAX_N = 1 << MAX_M;
TYPE soft[2*MAX_N];
TYPE hard[MAX_N];
public:
void operator()(TYPE *message, const TYPE *codeword, const uint8_t *frozen, int level)
void operator()(TYPE *message, const TYPE *codeword, const uint32_t *frozen, int level)
{
assert(level <= MAX_M);
int length = 1 << level;
@ -60,12 +170,7 @@ public:
soft[length+i] = codeword[i];
switch (level) {
case 0: PolarTree<TYPE, 0>::decode(&message, hard, soft, frozen); break;
case 1: PolarTree<TYPE, 1>::decode(&message, hard, soft, frozen); break;
case 2: PolarTree<TYPE, 2>::decode(&message, hard, soft, frozen); break;
case 3: PolarTree<TYPE, 3>::decode(&message, hard, soft, frozen); break;
case 4: PolarTree<TYPE, 4>::decode(&message, hard, soft, frozen); break;
case 5: PolarTree<TYPE, 5>::decode(&message, hard, soft, frozen); break;
case 5: PolarTree<TYPE, 5>::decode(&message, hard, soft, *frozen); break;
case 6: PolarTree<TYPE, 6>::decode(&message, hard, soft, frozen); break;
case 7: PolarTree<TYPE, 7>::decode(&message, hard, soft, frozen); break;
case 8: PolarTree<TYPE, 8>::decode(&message, hard, soft, frozen); break;