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:skip_stuff
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

5 commits
master ... skip_stuff

Author SHA1 Message Date
Ahmet Inan
40e6a90136 skip decoding frozen bits when no message bits yet 2026-01-26 00:47:25 +01:00
Ahmet Inan
831e17d878 skip permutation and shuffling for rate0 leafs 2026-01-24 12:52:07 +01:00
Ahmet Inan
cae677eeb1 skip redundant mixing of maps 2026-01-21 10:28:45 +01:00
Ahmet Inan
467122ac63 skip redundant operations 2026-01-21 08:51:55 +01:00
Ahmet Inan
a772aabdb8 skip permutation and shuffling for rate0 nodes 2026-01-21 08:51:55 +01:00
2 changed files with 341 additions and 145 deletions
Download patch file Download diff file Expand all files Collapse all files

233
pac_list_decoder.hh
View file

@ -11,8 +11,26 @@ Copyright 2025 Ahmet Inan <inan@aicodix.de>
namespace CODE { namespace CODE {
template <typename TYPE, int M>
struct PACListNode
{
typedef PolarHelper<TYPE> PH;
typedef typename PH::PATH PATH;
typedef typename PH::MAP MAP;
static const int N = 1 << M;
static void rate0(PATH *metric, TYPE *hard, TYPE *soft)
{
for (int i = 0; i < N; ++i)
hard[i] = PH::one();
for (int i = 0; i < N; ++i)
for (int k = 0; k < TYPE::SIZE; ++k)
if (soft[i+N].v[k] < 0)
metric[k] -= soft[i+N].v[k];
}
};
template <typename TYPE> template <typename TYPE>
struct PACListLeaf struct PACListNode<TYPE, 0>
{ {
typedef PolarHelper<TYPE> PH; typedef PolarHelper<TYPE> PH;
typedef typename PH::PATH PATH; typedef typename PH::PATH PATH;
@ -28,7 +46,7 @@ struct PACListLeaf
*state = ((*state & 126) << 1) | (input ? 2 : 0) | (output ? 1 : 0); *state = ((*state & 126) << 1) | (input ? 2 : 0) | (output ? 1 : 0);
return output; return output;
} }
static MAP rate0(PATH *metric, int *state, TYPE *hard, TYPE *soft) static void rate0(PATH *metric, int *state, TYPE *hard, TYPE *soft)
{ {
TYPE sft = soft[1]; TYPE sft = soft[1];
for (int k = 0; k < TYPE::SIZE; ++k) for (int k = 0; k < TYPE::SIZE; ++k)
@ -38,10 +56,6 @@ struct PACListLeaf
for (int k = 0; k < TYPE::SIZE; ++k) for (int k = 0; k < TYPE::SIZE; ++k)
hrd.v[k] = 1 - 2 * (state[k] & 1); hrd.v[k] = 1 - 2 * (state[k] & 1);
*hard = hrd; *hard = hrd;
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, int *state, TYPE *hard, TYPE *soft) static MAP rate1(PATH *metric, TYPE *message, MAP *maps, int *count, int *state, TYPE *hard, TYPE *soft)
{ {
@ -111,13 +125,33 @@ struct PACListTree<TYPE, 6>
{ {
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]); soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
MAP lmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard, soft, frozen[0]); MAP map;
for (int i = 0; i < N/2; ++i) bool left_frozen = frozen[0] == 0xffffffff && !*count;
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap)); if (left_frozen) {
MAP rmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard+N/2, soft, frozen[1]); PACListNode<TYPE, M-1>::rate0(metric, hard, soft);
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]); soft[i+N/2] = PH::qadd(soft[i+N], soft[i+N/2+N]);
return vshuf(lmap, rmap); } else {
map = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard, soft, frozen[0]);
for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], map), vshuf(soft[i+N/2+N], map));
}
bool right_frozen = frozen[1] == 0xffffffff && !*count;
if (right_frozen) {
PACListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
if (left_frozen)
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
} else {
MAP rmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard+N/2, soft, frozen[1]);
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]);
if (left_frozen)
map = rmap;
else
map = vshuf(map, rmap);
}
return map;
} }
}; };
@ -133,13 +167,33 @@ struct PACListTree<TYPE, 5>
{ {
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]); soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
MAP lmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard, soft, frozen & ((1<<(1<<(M-1)))-1)); MAP map;
for (int i = 0; i < N/2; ++i) bool left_frozen = (frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1) && !*count;
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap)); if (left_frozen) {
MAP rmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard+N/2, soft, frozen >> (N/2)); PACListNode<TYPE, M-1>::rate0(metric, hard, soft);
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]); soft[i+N/2] = PH::qadd(soft[i+N], soft[i+N/2+N]);
return vshuf(lmap, rmap); } else {
map = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, 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], map), vshuf(soft[i+N/2+N], map));
}
bool right_frozen = frozen >> (N/2) == ((1<<(1<<(M-1)))-1) && !*count;
if (right_frozen) {
PACListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
if (left_frozen)
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
} else {
MAP rmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard+N/2, soft, frozen >> (N/2));
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]);
if (left_frozen)
map = rmap;
else
map = vshuf(map, rmap);
}
return map;
} }
}; };
@ -155,13 +209,33 @@ struct PACListTree<TYPE, 4>
{ {
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]); soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
MAP lmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard, soft, frozen & ((1<<(1<<(M-1)))-1)); MAP map;
for (int i = 0; i < N/2; ++i) bool left_frozen = (frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1) && !*count;
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap)); if (left_frozen) {
MAP rmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard+N/2, soft, frozen >> (N/2)); PACListNode<TYPE, M-1>::rate0(metric, hard, soft);
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]); soft[i+N/2] = PH::qadd(soft[i+N], soft[i+N/2+N]);
return vshuf(lmap, rmap); } else {
map = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, 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], map), vshuf(soft[i+N/2+N], map));
}
bool right_frozen = frozen >> (N/2) == ((1<<(1<<(M-1)))-1) && !*count;
if (right_frozen) {
PACListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
if (left_frozen)
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
} else {
MAP rmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard+N/2, soft, frozen >> (N/2));
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]);
if (left_frozen)
map = rmap;
else
map = vshuf(map, rmap);
}
return map;
} }
}; };
@ -177,13 +251,33 @@ struct PACListTree<TYPE, 3>
{ {
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]); soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
MAP lmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard, soft, frozen & ((1<<(1<<(M-1)))-1)); MAP map;
for (int i = 0; i < N/2; ++i) bool left_frozen = (frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1) && !*count;
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap)); if (left_frozen) {
MAP rmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard+N/2, soft, frozen >> (N/2)); PACListNode<TYPE, M-1>::rate0(metric, hard, soft);
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]); soft[i+N/2] = PH::qadd(soft[i+N], soft[i+N/2+N]);
return vshuf(lmap, rmap); } else {
map = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, 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], map), vshuf(soft[i+N/2+N], map));
}
bool right_frozen = frozen >> (N/2) == ((1<<(1<<(M-1)))-1) && !*count;
if (right_frozen) {
PACListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
if (left_frozen)
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
} else {
MAP rmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard+N/2, soft, frozen >> (N/2));
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]);
if (left_frozen)
map = rmap;
else
map = vshuf(map, rmap);
}
return map;
} }
}; };
@ -199,13 +293,33 @@ struct PACListTree<TYPE, 2>
{ {
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]); soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
MAP lmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard, soft, frozen & ((1<<(1<<(M-1)))-1)); MAP map;
for (int i = 0; i < N/2; ++i) bool left_frozen = (frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1) && !*count;
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap)); if (left_frozen) {
MAP rmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard+N/2, soft, frozen >> (N/2)); PACListNode<TYPE, M-1>::rate0(metric, hard, soft);
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]); soft[i+N/2] = PH::qadd(soft[i+N], soft[i+N/2+N]);
return vshuf(lmap, rmap); } else {
map = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, 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], map), vshuf(soft[i+N/2+N], map));
}
bool right_frozen = frozen >> (N/2) == ((1<<(1<<(M-1)))-1) && !*count;
if (right_frozen) {
PACListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
if (left_frozen)
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
} else {
MAP rmap = PACListTree<TYPE, M-1>::decode(metric, message, maps, count, state, hard+N/2, soft, frozen >> (N/2));
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]);
if (left_frozen)
map = rmap;
else
map = vshuf(map, rmap);
}
return map;
} }
}; };
@ -218,18 +332,31 @@ struct PACListTree<TYPE, 1>
static MAP decode(PATH *metric, TYPE *message, MAP *maps, int *count, int *state, TYPE *hard, TYPE *soft, uint32_t frozen) static MAP decode(PATH *metric, TYPE *message, MAP *maps, int *count, int *state, TYPE *hard, TYPE *soft, uint32_t frozen)
{ {
soft[1] = PH::prod(soft[2], soft[3]); soft[1] = PH::prod(soft[2], soft[3]);
MAP lmap, rmap; MAP map;
if (frozen & 1) bool left_frozen = frozen & 1;
lmap = PACListLeaf<TYPE>::rate0(metric, state, hard, soft); if (left_frozen) {
else PACListNode<TYPE, 0>::rate0(metric, state, hard, soft);
lmap = PACListLeaf<TYPE>::rate1(metric, message, maps, count, state, hard, soft); soft[1] = PH::madd(hard[0], soft[2], soft[3]);
soft[1] = PH::madd(hard[0], vshuf(soft[2], lmap), vshuf(soft[3], lmap)); } else {
if (frozen >> 1) map = PACListNode<TYPE, 0>::rate1(metric, message, maps, count, state, hard, soft);
rmap = PACListLeaf<TYPE>::rate0(metric, state, hard+1, soft); soft[1] = PH::madd(hard[0], vshuf(soft[2], map), vshuf(soft[3], map));
else }
rmap = PACListLeaf<TYPE>::rate1(metric, message, maps, count, state, hard+1, soft); bool right_frozen = frozen >> 1;
hard[0] = PH::qmul(vshuf(hard[0], rmap), hard[1]); if (right_frozen) {
return vshuf(lmap, rmap); PACListNode<TYPE, 0>::rate0(metric, state, hard+1, soft);
hard[0] = PH::qmul(hard[0], hard[1]);
if (left_frozen)
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
} else {
MAP rmap = PACListNode<TYPE, 0>::rate1(metric, message, maps, count, state, hard+1, soft);
hard[0] = PH::qmul(vshuf(hard[0], rmap), hard[1]);
if (left_frozen)
map = rmap;
else
map = vshuf(map, rmap);
}
return map;
} }
}; };

253
polar_list_decoder.hh
View file

@ -18,7 +18,7 @@ struct PolarListNode
typedef typename PH::PATH PATH; typedef typename PH::PATH PATH;
typedef typename PH::MAP MAP; typedef typename PH::MAP MAP;
static const int N = 1 << M; static const int N = 1 << M;
static MAP rate0(PATH *metric, TYPE *hard, TYPE *soft) static void rate0(PATH *metric, TYPE *hard, TYPE *soft)
{ {
for (int i = 0; i < N; ++i) for (int i = 0; i < N; ++i)
hard[i] = PH::one(); hard[i] = PH::one();
@ -26,10 +26,6 @@ struct PolarListNode
for (int k = 0; k < TYPE::SIZE; ++k) for (int k = 0; k < TYPE::SIZE; ++k)
if (soft[i+N].v[k] < 0) if (soft[i+N].v[k] < 0)
metric[k] -= soft[i+N].v[k]; metric[k] -= soft[i+N].v[k];
MAP map;
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
return map;
} }
}; };
@ -39,16 +35,12 @@ struct PolarListNode<TYPE, 0>
typedef PolarHelper<TYPE> PH; typedef PolarHelper<TYPE> PH;
typedef typename PH::PATH PATH; typedef typename PH::PATH PATH;
typedef typename PH::MAP MAP; typedef typename PH::MAP MAP;
static MAP rate0(PATH *metric, TYPE *hard, TYPE *soft) static void rate0(PATH *metric, TYPE *hard, TYPE *soft)
{ {
*hard = PH::one(); *hard = PH::one();
for (int k = 0; k < TYPE::SIZE; ++k) for (int k = 0; k < TYPE::SIZE; ++k)
if (soft[1].v[k] < 0) if (soft[1].v[k] < 0)
metric[k] -= soft[1].v[k]; 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) static MAP rate1(PATH *metric, TYPE *message, MAP *maps, int *count, TYPE *hard, TYPE *soft)
{ {
@ -112,20 +104,33 @@ struct PolarListTree<TYPE, 6>
{ {
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]); soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
MAP lmap, rmap; MAP map;
if (frozen[0] == 0xffffffff) bool left_frozen = frozen[0] == 0xffffffff;
lmap = PolarListNode<TYPE, M-1>::rate0(metric, hard, soft); if (left_frozen) {
else PolarListNode<TYPE, M-1>::rate0(metric, hard, soft);
lmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard, soft, frozen[0]); for (int i = 0; i < N/2; ++i)
for (int i = 0; i < N/2; ++i) soft[i+N/2] = PH::qadd(soft[i+N], soft[i+N/2+N]);
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap)); } else {
if (frozen[1] == 0xffffffff) map = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard, soft, frozen[0]);
rmap = PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft); for (int i = 0; i < N/2; ++i)
else soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], map), vshuf(soft[i+N/2+N], map));
rmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard+N/2, soft, frozen[1]); }
for (int i = 0; i < N/2; ++i) bool right_frozen = frozen[1] == 0xffffffff;
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]); if (right_frozen) {
return vshuf(lmap, rmap); PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
if (left_frozen)
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
} else {
MAP rmap = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard+N/2, soft, frozen[1]);
for (int i = 0; i < N/2; ++i)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]);
if (left_frozen)
map = rmap;
else
map = vshuf(map, rmap);
}
return map;
} }
}; };
@ -141,20 +146,33 @@ struct PolarListTree<TYPE, 5>
{ {
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]); soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
MAP lmap, rmap; MAP map;
if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1)) bool left_frozen = (frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1);
lmap = PolarListNode<TYPE, M-1>::rate0(metric, hard, soft); if (left_frozen) {
else PolarListNode<TYPE, M-1>::rate0(metric, hard, soft);
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)
for (int i = 0; i < N/2; ++i) soft[i+N/2] = PH::qadd(soft[i+N], soft[i+N/2+N]);
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap)); } else {
if (frozen >> (N/2) == ((1<<(1<<(M-1)))-1)) map = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
rmap = PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft); for (int i = 0; i < N/2; ++i)
else soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], map), vshuf(soft[i+N/2+N], map));
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) bool right_frozen = frozen >> (N/2) == ((1<<(1<<(M-1)))-1);
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]); if (right_frozen) {
return vshuf(lmap, rmap); PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
if (left_frozen)
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
} else {
MAP 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)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]);
if (left_frozen)
map = rmap;
else
map = vshuf(map, rmap);
}
return map;
} }
}; };
@ -170,20 +188,33 @@ struct PolarListTree<TYPE, 4>
{ {
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]); soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
MAP lmap, rmap; MAP map;
if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1)) bool left_frozen = (frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1);
lmap = PolarListNode<TYPE, M-1>::rate0(metric, hard, soft); if (left_frozen) {
else PolarListNode<TYPE, M-1>::rate0(metric, hard, soft);
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)
for (int i = 0; i < N/2; ++i) soft[i+N/2] = PH::qadd(soft[i+N], soft[i+N/2+N]);
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap)); } else {
if (frozen >> (N/2) == ((1<<(1<<(M-1)))-1)) map = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
rmap = PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft); for (int i = 0; i < N/2; ++i)
else soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], map), vshuf(soft[i+N/2+N], map));
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) bool right_frozen = frozen >> (N/2) == ((1<<(1<<(M-1)))-1);
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]); if (right_frozen) {
return vshuf(lmap, rmap); PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
if (left_frozen)
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
} else {
MAP 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)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]);
if (left_frozen)
map = rmap;
else
map = vshuf(map, rmap);
}
return map;
} }
}; };
@ -199,20 +230,33 @@ struct PolarListTree<TYPE, 3>
{ {
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]); soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
MAP lmap, rmap; MAP map;
if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1)) bool left_frozen = (frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1);
lmap = PolarListNode<TYPE, M-1>::rate0(metric, hard, soft); if (left_frozen) {
else PolarListNode<TYPE, M-1>::rate0(metric, hard, soft);
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)
for (int i = 0; i < N/2; ++i) soft[i+N/2] = PH::qadd(soft[i+N], soft[i+N/2+N]);
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap)); } else {
if (frozen >> (N/2) == ((1<<(1<<(M-1)))-1)) map = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
rmap = PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft); for (int i = 0; i < N/2; ++i)
else soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], map), vshuf(soft[i+N/2+N], map));
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) bool right_frozen = frozen >> (N/2) == ((1<<(1<<(M-1)))-1);
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]); if (right_frozen) {
return vshuf(lmap, rmap); PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
if (left_frozen)
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
} else {
MAP 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)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]);
if (left_frozen)
map = rmap;
else
map = vshuf(map, rmap);
}
return map;
} }
}; };
@ -228,20 +272,33 @@ struct PolarListTree<TYPE, 2>
{ {
for (int i = 0; i < N/2; ++i) for (int i = 0; i < N/2; ++i)
soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]); soft[i+N/2] = PH::prod(soft[i+N], soft[i+N/2+N]);
MAP lmap, rmap; MAP map;
if ((frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1)) bool left_frozen = (frozen & ((1<<(1<<(M-1)))-1)) == ((1<<(1<<(M-1)))-1);
lmap = PolarListNode<TYPE, M-1>::rate0(metric, hard, soft); if (left_frozen) {
else PolarListNode<TYPE, M-1>::rate0(metric, hard, soft);
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)
for (int i = 0; i < N/2; ++i) soft[i+N/2] = PH::qadd(soft[i+N], soft[i+N/2+N]);
soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], lmap), vshuf(soft[i+N/2+N], lmap)); } else {
if (frozen >> (N/2) == ((1<<(1<<(M-1)))-1)) map = PolarListTree<TYPE, M-1>::decode(metric, message, maps, count, hard, soft, frozen & ((1<<(1<<(M-1)))-1));
rmap = PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft); for (int i = 0; i < N/2; ++i)
else soft[i+N/2] = PH::madd(hard[i], vshuf(soft[i+N], map), vshuf(soft[i+N/2+N], map));
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) bool right_frozen = frozen >> (N/2) == ((1<<(1<<(M-1)))-1);
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]); if (right_frozen) {
return vshuf(lmap, rmap); PolarListNode<TYPE, M-1>::rate0(metric, hard+N/2, soft);
if (left_frozen)
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
} else {
MAP 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)
hard[i] = PH::qmul(vshuf(hard[i], rmap), hard[i+N/2]);
if (left_frozen)
map = rmap;
else
map = vshuf(map, rmap);
}
return map;
} }
}; };
@ -254,18 +311,30 @@ struct PolarListTree<TYPE, 1>
static MAP decode(PATH *metric, TYPE *message, MAP *maps, int *count, TYPE *hard, TYPE *soft, uint32_t frozen) 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]); soft[1] = PH::prod(soft[2], soft[3]);
MAP lmap, rmap; MAP map;
if (frozen & 1) bool left_frozen = frozen & 1;
lmap = PolarListNode<TYPE, 0>::rate0(metric, hard, soft); if (left_frozen) {
else PolarListNode<TYPE, 0>::rate0(metric, hard, soft);
lmap = PolarListNode<TYPE, 0>::rate1(metric, message, maps, count, hard, soft); soft[1] = PH::qadd(soft[2], soft[3]);
soft[1] = PH::madd(hard[0], vshuf(soft[2], lmap), vshuf(soft[3], lmap)); } else {
if (frozen >> 1) map = PolarListNode<TYPE, 0>::rate1(metric, message, maps, count, hard, soft);
rmap = PolarListNode<TYPE, 0>::rate0(metric, hard+1, soft); soft[1] = PH::madd(hard[0], vshuf(soft[2], map), vshuf(soft[3], map));
else }
rmap = PolarListNode<TYPE, 0>::rate1(metric, message, maps, count, hard+1, soft); bool right_frozen = frozen >> 1;
hard[0] = PH::qmul(vshuf(hard[0], rmap), hard[1]); if (right_frozen) {
return vshuf(lmap, rmap); PolarListNode<TYPE, 0>::rate0(metric, hard+1, soft);
if (left_frozen)
for (int k = 0; k < TYPE::SIZE; ++k)
map.v[k] = k;
} else {
MAP rmap = PolarListNode<TYPE, 0>::rate1(metric, message, maps, count, hard+1, soft);
hard[0] = PH::qmul(vshuf(hard[0], rmap), hard[1]);
if (left_frozen)
map = rmap;
else
map = vshuf(map, rmap);
}
return map;
} }
}; };