def encode_matrix(u, N, frozenBitMap):
n = int(np.log2(N))
G = get_polar_generator_matrix(n)
x = np.copy(frozenBitMap)
x[np.where(frozenBitMap == -1)] = u
x = x.dot(G) % 2
return x
def check_matrix_domination_contiguity(self, N, f):
f = np.array(f)
G = get_polar_generator_matrix(int(np.log2(N)))
em = get_expanding_matrix(f, N)
bpi = np.dot(em, np.dot(G, em.T) % 2) % 2
r = np.dot(bpi, bpi) % 2
return np.all(r == np.identity(N - len(f)))
def encode_polar_reversed(u, N, frozenBitMap):
n = int(np.log2(N))
G = get_polar_generator_matrix(n)
x = np.copy(frozenBitMap)
x[np.where(frozenBitMap == -1)] = u
# print(u, x, np.where(frozenBitMap == -1))
# print(frozenBitMap[np.where(frozenBitMap > -1)])
x = x.dot(G) % 2
return x
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)
def calculate_code_properties(N, K, design_snr_db):
eta = design_snr_to_bec_eta(design_snr_db, 1.0 * K / N)
polar_capacities = calculate_bec_channel_capacities(eta, N)
frozenBitMap = get_frozenBitMap(polar_capacities, N - K)
f = pypolar.frozen_bits(N, K, design_snr_db)
p = pypolar.PolarEncoder(N, f)
Gp = get_polar_generator_matrix(int(np.log2(N)))
print(Gp)
assert np.all(np.where(frozenBitMap > -1) == f)
numInfoWords = 2 ** K
n_prepend_bits = int(8 * np.ceil(K / 8.) - K)
print(n_prepend_bits)
weights = {}
for i in range(numInfoWords):
# b = np.binary_repr(i, K + n_prepend_bits)
b = np.binary_repr(i, K)
u = np.array([int(l) for l in b], dtype=np.uint8)
# nb = np.concatenate((np.zeros(n_prepend_bits, dtype=nb.dtype), nb))
nbp = np.packbits(u)
cw = p.encode_vector(nbp)
# xm = encode_systematic_matrix(u, N, frozenBitMap)
c = np.unpackbits(cw)
# assert np.all(xm == c)
weight = np.sum(c)
if weight in weights:
weights[weight] += 1
else:
weights[weight] = 1
# nb = bin(i)
# print(i, b, u, nbp, c)
print(f)
print(frozenBitMap)
# print(n_prepend_bits)
weights.pop(0)
print(weights)
dmin_ext_search = np.min(weights.keys())
print(dmin_ext_search)
# validate_systematic_matrix(N, f, frozenBitMap)
Gs = get_polar_encoder_matrix_systematic(N, f)
P = Gs[:, f]
# print(P)
G = np.hstack((np.identity(K, dtype=Gs.dtype), P))
H = np.hstack((P.T, np.identity(N - K, dtype=Gs.dtype)))
# print(P)
print(H)
# print(G.dot(H.T) % 2)
#
# print(Gs.dot(Gs.T) % 2)
print(np.linalg.matrix_rank(H))
dmin_H = np.min(np.sum(H, axis=1))
dmin_P = 1 + np.min(np.sum(P, axis=1))
print(np.sum(H, axis=1))
print(np.sum(P, axis=1))
print('search {} vs {} H, P{}'.format(dmin_ext_search, dmin_H, dmin_P))
assert dmin_ext_search == dmin_P