def test_bit_count_random(self):
for n in list(range(50)) + [randint(1000, 2000)]:
a = urandom(n)
b = urandom(n)
self.assertEqual(count_and(a, b), (a & b).count())
self.assertEqual(count_or(a, b), (a | b).count())
self.assertEqual(count_xor(a, b), (a ^ b).count())
def test():
from random import randint
from bitarray.util import urandom
a = [
urandom(n * n, endian=['little', 'big'][randint(0, 1)])
for n in range(12)
]
a.append({'key1': bitarray('010'), 'key2': 'value2', 'key3': urandom(300)})
j = JSONEncoder(indent=2).encode(a)
print(j)
b = JSONDecoder().decode(j)
assert a == b
assert b[-1]['key1'] == bitarray('010')
def test_binascii(self):
a = urandom(800, 'big')
s = binascii.hexlify(a.tobytes()).decode()
self.assertEqual(ba2hex(a), s)
b = bitarray(endian='big')
b.frombytes(binascii.unhexlify(s))
self.assertEQUAL(hex2ba(s, 'big'), b)
def test_bitwise_inplace(self):
for a in self.randombitarrays(start=1):
b = urandom(len(a), a.endian())
bb = b.copy()
i = ba2int(a)
j = ba2int(b)
c = a.copy()
c &= b
self.assertEqual(ba2int(c), i & j)
c = a.copy()
c |= b
self.assertEqual(ba2int(c), i | j)
c = a.copy()
c ^= b
self.assertEqual(ba2int(c), i ^ j)
self.assertEQUAL(b, bb)
n = randint(0, len(a))
if a.endian() == 'big':
c = a.copy()
c >>= n
self.assertEqual(ba2int(c), i >> n)
c = zeros(len(a)) + a
c <<= n
self.assertEqual(ba2int(c), i << n)
def test_random2(self):
for m in range(1, 7):
n = 1 << m
for length in range(0, 100, m):
a = urandom(length, 'little')
self.assertEQUAL(base2ba(n, ba2base(n, a), 'little'), a)
b = bitarray(a, 'big')
self.assertEQUAL(base2ba(n, ba2base(n, b), 'big'), b)
def test_1(self):
for default_endian in 'big', 'little':
_set_default_endian(default_endian)
a = urandom(0)
self.assertEqual(a, bitarray())
self.assertEqual(a.endian(), default_endian)
b = urandom(0, endian=None)
self.assertEqual(b.endian(), default_endian)
for n in range(100):
a = urandom(n)
self.assertEqual(len(a), n)
self.assertEqual(b.endian(), default_endian)
a = urandom(1000)
b = urandom(1000)
self.assertNotEqual(a, b)
self.assertTrue(400 < a.count() < 600)
self.assertTrue(400 < b.count() < 600)
def test_basic(self):
for default_endian in 'big', 'little':
_set_default_endian(default_endian)
a = urandom(0)
self.assertEqual(a, bitarray())
self.assertEqual(a.endian(), default_endian)
a = urandom(7, endian=None)
self.assertEqual(len(a), 7)
self.assertEqual(a.endian(), default_endian)
for n in range(50):
a = urandom(n)
self.assertEqual(len(a), n)
self.assertEqual(a.endian(), default_endian)
for endian in 'big', 'little':
a = urandom(11, endian)
self.assertEqual(len(a), 11)
self.assertEqual(a.endian(), endian)
def test_round(f, g, n, endian):
# f: function which takes bitarray and returns hexstr
# g: function which takes hexstr and returns bitarray
# n: size of random bitarray
a = urandom(n, endian)
t0 = time()
s = f(a)
print('%s: %9.6f sec' % (f.__name__, time() - t0))
t0 = time()
b = g(s, endian)
print('%s: %9.6f sec' % (g.__name__, time() - t0))
assert b == a
def test_bitwise(self):
for a in self.randombitarrays(start=1):
b = urandom(len(a), a.endian())
aa = a.copy()
bb = b.copy()
i = ba2int(a)
j = ba2int(b)
self.assertEqual(ba2int(a & b), i & j)
self.assertEqual(ba2int(a | b), i | j)
self.assertEqual(ba2int(a ^ b), i ^ j)
n = randint(0, len(a))
if a.endian() == 'big':
self.assertEqual(ba2int(a >> n), i >> n)
c = zeros(len(a)) + a
self.assertEqual(ba2int(c << n), i << n)
self.assertEQUAL(a, aa)
self.assertEQUAL(b, bb)
def test():
from random import randint
from bitarray.util import urandom
a = [
urandom(n * n, endian=['little', 'big'][randint(0, 1)])
for n in range(10)
]
a.append({'key1': bitarray('010'), 'key2': 'value2'})
j = JSONEncoder(indent=2).encode(a)
print(j)
b = JSONDecoder().decode(j)
assert a == b
for i in range(len(a)):
if isinstance(a[i], bitarray):
assert a[i] == b[i]
assert a[i].endian() == b[i].endian()
assert b[-1]['key1'] == bitarray('010')
assert b[-1]['key2'] == 'value2'
def test_random(self):
for n in range(150):
self.round_trip(urandom(n))
def test_random(self):
for n in range(1, 10):
a = urandom(n, self.random_endian())
self.check_all_perm(a)
a.sort(a.endian() == 'little')
self.check_order(a)
from bitarray.util import urandom
if __name__ == "__main__":
file = open("result", "w+")
data = urandom(5120000)
file.write(data.to01())
from __future__ import print_function
from bitarray.util import urandom, pprint, ba2base, base2ba
a = urandom(60)
for m in range(1, 7):
n = 1 << m
print("----- length: %d ----- base: %d ----- " % (m, n))
pprint(a, group=m)
rep = ba2base(n, a)
print("representation:", rep)
print()
assert base2ba(n, rep) == a
def main():
start = time.time()
# a = []
# b = []
# for i in range(0, 30):
generated_array = Generator().populate_array(2**18)
# print(generated_array)
coded_array = Coder().triple_code(generated_array)
# print(coded_array)
# a.append(i / 100)
# distorted_array = Channel(i/100).distort(coded_array)
distorted_array = Channel(0.15).distort(coded_array)
# print(distorted_array)
decoded_array = Decoder().decode(distorted_array)
# print(decoded_array)
print(error_factor(generated_array, decoded_array))
# b.append(error_factor(generated_array, decoded_array))
# print(a, b)
# plt.plot(a, b)
# plt.title("Error percentage depending on the probability p")
# plt.xlabel("Probability of error p")
# plt.ylabel("Error factor in %")
# plt.show()
end = time.time()
print("Time:", end-start)
"""
Etap II
"""
print("Stage 2")
# 2048
bch = BCH()
a = []
b = []
error = 0
sent_msg = b_util.urandom(512)
m = 8
t = 63
k = 9
# 7_21_29
# received_msg = BCH.code(sent_msg, m, t, k, 0.3)
# for i in range(0, 20, 1):
# for j in range(10):
# received_msg = BCH.code(sent_msg, 3, 1, 4, i/100)
# filled_array = fill_with_zeros(sent_msg, len(received_msg))
# # print(len(example_bit_array), len(received_msg))
# # # print(received_msg)
# # print("Error [%] - decoded msg: ", error_factor(example_bit_array, received_msg))
# error += error_factor(filled_array, received_msg)
# error /= 10
# a.append(i/100)
# b.append(error)
# print(a, b)
# plt.plot(a, b)
# plt.title(
# f"Error percentage depending on the probability p \nfor m = {m} k = {k} t = {t}")
# plt.xlabel("Probability of error p")
# plt.ylabel("Error factor in %")
# plt.show()
for i in range(0,20,3):
counter = 0
for m in bch_code_parameters:
for t in bch_code_parameters[m]:
counter +=1
received_msg = BCH.code(sent_msg, m, t, bch_code_parameters[m][t], i/100)
filled_array = fill_with_zeros(sent_msg, len(received_msg))
# print(len(example_bit_array), len(received_msg))
# # print(received_msg)
# print("Error [%] - decoded msg: ", error_factor(example_bit_array, received_msg))
error += error_factor(filled_array, received_msg)
a.append(i/100)
b.append(error/counter)
error = 0
print(counter)
print(a, b)
plt.plot(a, b)
plt.title("Error percentage depending on the probability p")
plt.xlabel("Probability of error p")
plt.ylabel("Error factor in %")
plt.show()
def test_count(self):
a = urandom(1000)
b = urandom(1000)
self.assertNotEqual(a, b)
self.assertTrue(400 < a.count() < 600)
self.assertTrue(400 < b.count() < 600)
