def test_003_depuncture_bits(self):
N = 2**6
K = N // 2
eta = design_snr_to_bec_eta(0.0, 1.0)
polar_capacities = calculate_bec_channel_capacities(eta, N)
f = np.sort(get_frozenBitPositions(polar_capacities, N - K))
punc = pypolar.Puncturer(N - (N // 4), f)
outputPositions = get_diff_positions(N, f[0:N // 4])
vec = np.random.normal(0.0, 1.0, N - (N // 4)).astype(np.float32)
res = punc.depuncture(vec)
ref = np.zeros(N, dtype=res.dtype)
ref[outputPositions] = vec
self.assertListEqual(ref.tolist(), res.tolist())
vec = np.random.normal(0.0, 1.0, N - (N // 4)).astype(np.float64)
res = punc.depuncture(vec)
ref = np.zeros(N, dtype=res.dtype)
ref[outputPositions] = vec
self.assertListEqual(ref.tolist(), res.tolist())
vec = np.random.randint(0, 256, N - (N // 4), dtype=np.uint8)
res = punc.depuncture(vec)
ref = np.zeros(N, dtype=res.dtype)
ref[outputPositions] = vec
self.assertListEqual(ref.tolist(), res.tolist())
def test_002_puncture_bits(self):
N = 2**6
K = N // 2
eta = design_snr_to_bec_eta(0.0, 1.0)
polar_capacities = calculate_bec_channel_capacities(eta, N)
f = np.sort(get_frozenBitPositions(polar_capacities, N - K))
outputPositions = get_diff_positions(N, f[0:N // 4])
punc = pypolar.Puncturer(N - (N // 4), f)
vec = np.random.randint(0, 256, N // 8, dtype=np.uint8)
unpvec = np.unpackbits(vec)
unpres = punc.puncture(unpvec)
res = punc.puncturePacked(vec)
self.assertListEqual(np.unpackbits(res).tolist(), unpres.tolist())
ref = unpvec[outputPositions]
self.assertListEqual(ref.tolist(), unpres.tolist())
fvec = np.arange(N, dtype=np.float32)
fres = punc.puncture(fvec)
fref = fvec[outputPositions]
self.assertListEqual(fref.tolist(), fres.tolist())
dvec = np.arange(N, dtype=np.float64)
dres = punc.puncture(dvec)
dref = dvec[outputPositions]
self.assertListEqual(dref.tolist(), dres.tolist())
def test_002_frozen_bit_positions(self):
for snr in np.arange(-1.5, 3.5, .25):
for inv_coderate in np.array([8, 6, 5, 4, 3, 2, 1.5, 1.2]):
for n in range(6, 11):
N = 2**n
K = int(N / inv_coderate)
# print(N, K, inv_coderate)
cf = pypolar.frozen_bits(N, K, snr)
eta = design_snr_to_bec_eta(snr, 1. * K / N)
polar_capacities = calculate_bec_channel_capacities(eta, N)
pf = get_frozenBitPositions(polar_capacities, N - K)
pf = np.sort(pf)
decoder = pypolar.PolarDecoder(N, 1, cf, "mixed")
pd = decoder.frozenBits()
self.assertListEqual(cf, pd)
self.assertListEqual(cf, list(pf))
def validate_config(self, N, K, snr):
eta = design_snr_to_bec_eta(snr, 1.0)
polar_capacities = calculate_bec_channel_capacities(eta, N)
f = get_frozenBitPositions(polar_capacities, N - K)
f = np.sort(f)
frozenBitMap = get_frozenBitMap(polar_capacities, N - K)
info_pos = np.setdiff1d(np.arange(N, dtype=f.dtype), f)
self.assertEqual(info_pos.size, K)
self.assertEqual(f.size, N - K)
self.assertEqual(np.sum(frozenBitMap), -K)
p = pypolar.PolarEncoder(N, f)
self.assertEqual(p.blockLength(), N)
self.assertTrue(np.all(f == p.frozenBits()))
self.assertTrue(np.all(f == np.arange(N)[np.where(frozenBitMap == 0)]))
self.assertTrue(p.isSystematic())
p.setSystematic(False)
self.assertFalse(p.isSystematic())
p.setSystematic(True)
self.assertTrue(p.isSystematic())
self.check_matrix_domination_contiguity(N, p.frozenBits())
def test_001_setup(self):
for n in range(5, 11):
N = 2**n
K = N // 2
eta = design_snr_to_bec_eta(0.0, 1.0)
polar_capacities = calculate_bec_channel_capacities(eta, N)
f = np.sort(get_frozenBitPositions(polar_capacities, N - K))
outputPositions0 = get_diff_positions(N, f[0:N // 4])
punc0 = pypolar.Puncturer(N - (N // 4), f)
self.assertEqual(punc0.parentBlockLength(), N)
self.assertEqual(punc0.blockLength(), N - (N // 4))
self.assertListEqual(punc0.blockOutputPositions(),
outputPositions0.tolist())
outputPositions1 = get_diff_positions(N, f[0:N // 8])
punc1 = pypolar.Puncturer(N - (N // 8), f)
self.assertEqual(punc1.parentBlockLength(), N)
self.assertEqual(punc1.blockLength(), N - (N // 8))
self.assertListEqual(punc1.blockOutputPositions(),
outputPositions1.tolist())
def matrix_validation(self, N, K, snr):
eta = design_snr_to_bec_eta(snr, 1.0)
polar_capacities = calculate_bec_channel_capacities(eta, N)
f = np.sort(get_frozenBitPositions(polar_capacities, N - K))
ip = np.setdiff1d(np.arange(N, dtype=f.dtype), f)
frozenBitMap = get_frozenBitMap(polar_capacities, N - K)
n = int(np.log2(N))
G = get_polar_generator_matrix(n)
Gs = get_polar_encoder_matrix_systematic(N, f)
for i in range(10):
u = np.random.randint(0, 2, K).astype(dtype=np.uint8)
x = np.zeros(N, dtype=np.uint8)
x[ip] = u
xref = np.copy(frozenBitMap)
xref[np.where(frozenBitMap == -1)] = u
self.assertTrue(np.all(x == xref))
x = x.dot(G) % 2
x[f] = 0
x = x.dot(G) % 2
xs = u.dot(Gs) % 2
self.assertTrue(np.all(x == xs))
self.matrix_gen_check_validation(Gs, f)