def test_heptad_completer(gc, gc_ref):
hc = gc_ref.heptad_completer
for p, ok in get_testdata(gc_ref):
p_in = p[:6] + [None] * 2 + p[8:9] + [None] * 15
if ok:
err = gc.perm_complete_heptad(p_in)
#assert err == 0, (p_in, hex(err))
if not None in p:
assert list(p) == list(p_in), (p, p_in, hex(err))
i = hc.perm_to_int(p)
assert 0 <= i < 244823040
p1 = hc.int_to_perm(i)
assert list(p) == list(p1), (i, p, p1)
else:
with pytest.raises(ValueError):
gc.perm_complete_heptad(p_in)
if ok:
hexad = p[:6] + [None] * 2
hexad_ref = hexad[:]
gc.perm_complete_octad(hexad)
assert hexad == p_in[:8]
gc_ref.perm_complete_octad(hexad_ref)
assert hexad_ref == p_in[:8]
for h1, h2 in heptad_testdata(gc_ref):
p = gc.perm_from_heptads(h1, h2)
for i in range(7):
assert p[h1[i]] == h2[i]
perm0 = gc.perm_to_m24num(lrange(24))
assert perm0 == 0, perm0
print("Heptad completer test passed")
def test_v2():
for i in lrange(300) + [100000]:
assert bitlen(1 << i) == i + 1
assert bitlen((1 << i) - 1) == i
for i in v2_testcases():
assert v2(i) == v2_old(i), (hex(i), v2(i), v2_old(i))
pass
def benes24_testdata(ntests=1000):
for i in range(10):
p1 = [0,8,16]; shuffle(p1)
p = [ [p1[j]] + lrange(8*j+1,8*j+8) for j in range(3) ]
x = randint(0, 2**24-1)
yield x, sum(p, [])
for i in range(10):
x = randint(0, 2**24-1)
p0 = lrange(0,8); shuffle(p0)
p1 = lrange(8,16); shuffle(p1)
p2 = lrange(16,24); shuffle(p2)
yield x , p0 + p1 + p2
for i in range(ntests):
x = randint(0, 2**24-1)
p0 = lrange(0,24); shuffle(p0)
yield x, p0
def test_benes_steps():
do_benes_step(4,0, [1,2,0,3])
do_benes_step(4,1, [1,2,0,3])
for t in range(10):
for n in (4,8,16,32):
for sh in range(5):
if 1 << sh < n:
l = lrange(n)
shuffle(l)
do_benes_step(n, sh, l)
for t in range(10):
l = lrange(32)
shuffle(l)
for i in range(4):
_1, _2, l = benes_step(32, i, l)
benes_step_final(32, 4, l)
def inverse_testcases():
testcases = [
[3, 4, 6, 12],
[2, 3],
]
NTESTS = 100
for a in testcases:
yield a
for j in range(NTESTS):
for n in lrange(1, 13) + [24]:
a = bit_mat_random(n, n)
yield a
for j in range(200):
yield bit_mat_random(10, 10)
def get_testdata(gc):
hc = gc.heptad_completer
import random
prod = lrange(24)
yield prod, True
for i in range(100):
p = random_umbral_heptad(gc)
yield p, True
hc.complete_heptad(p)
prod = gc.mul_perm(prod, p)
#print( prod )
yield p, True
# test some error cases
for i in range(100):
p = random_umbral_heptad(gc)
hc.complete_heptad(p)
p6 = p[6]
j = random.randint(0, 5)
p[j], p[8] = p[8], p[j]
yield p, False
p[j], p[8] = p[8], p[j]
yield p, True
ok_j = p[j]
p[j] = p[8]
yield p, False
p[j] = random.randint(24, 32)
yield p, False
p[j] = ok_j
yield p, True
p[8] = p6
yield p, False
p[8] = p[j]
yield p, False
p[8] = random.randint(24, 32)
yield p, False
for i in range(6):
for j in range(i):
p = random_umbral_heptad(gc)
hc.complete_heptad(p)
p[i] = p[j]
yield p, False
def v2_testcases():
for i in lrange(32) + lrange(32, 70, 3):
yield (1 << i)
if i: yield (1 << i) - 1