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 compute(self, basis):
"""Calculate the permutation from a (transformed) basis.
Here we calculate the singletons from the transformed basis.
The same calculations with the standard basis self.basis yields
the singletons 0,...,23 in that order. So the singletons from
the transformed basis are the images of 0,...,23.
The tables self.basis_augment, self.col_aux_table,
self.bw_aux_table, self.out_table[i] are used.
Singleton i is represented as 2**i, so at the end we have to take
binary logarithms.
"""
basis = basis[:12]
for l in self.basis_augment:
basis.append(reduce(__xor__, [basis[x] for x in l], 0))
t = []
for z in self.col_aux_table + self.bw_aux_table:
t.append(reduce(__and__, [basis[i] ^ -s for (i, s) in z]))
out = []
st = len(self.col_aux_table)
for i in range(24):
m = t[st + (i >> 2)] & t[self.out_table[i]]
out.append(v2(m))
return out
def display_operand(value):
if value in registers:
return 'o[%d]' % registers[value]
if value == 0:
return "0"
if bitweight(value) == 1:
return "i[%d]" % v2(value)
raise ValueError("Illegal operand in straight line program")
def test_lsbit24(gc):
for x in lsbit24_testcases():
try:
v_ref = min(v2(x), 24)
except:
v_ref = 24
v = gc.lsbit24(x)
assert v == v_ref, (hex(x), v, v_ref)
print("test of lsbit determination passed")
def operand_name(self, x, registers):
if x in registers:
return self.register_name(registers[x])
if x == 0:
return "0"
r = v2(x)
assert x == 1 << r
return "(%s)(%s)" % (self.type_name,
self.array_entry(self.input_name, r))
def make_theta_table():
r"""Creates the theta function for the Parker Loop
theta() is a function from the Golay code C to the Golay cocode C*.
Multiplication '(*)' in the Parker loop is defined by:
a (*) b = (a ^ b) * (-1) ** scalar(theta(a),b) ,
Where '^' is the vector addition in GF(2)**12, and scalar(.,.)
is the scalar product defined on C x C*.
More specifically, theta is a quadratic form from C onto C*. The
basis cc_i, i=0,...,11 of the cocode defined here is reciprocal to
the basis c_i, i=0,...,11 of the cocode defined here.
Define theta(i)[j] = theta(i) * c_j. Then
theta(i) = sum[1 << theta(i)[j] for j in range(12) ].
To define theta as a quadratic form, it suffices to define theta
on the basis vectors. We define theta on the basis vectors as
given by function theta_to_basis_vector(v).
There is a symmetric bilinear form B : from C x C onto C*
associated with theta on all pairs of basis vectors satisfying:
B(x,y) = theta(x+y) + theta(x) + theta(y) .
B(x,y) = x :math:`\cap` Y
Here :math:`\cap means intersection (i.e. bitwise 'and' in
GF(2)**24) of two Golay code words. This allows us to compute
theta(x), for all Golay code words, if theta is given on a
basis of the Golay code.
"""
assert Mat24Tables.gcode_to_vect(0x800) == 0xffffff
theta_table = numpy.zeros(0x800, dtype = uint16)
thetas = theta_basis_vectors()
for i in range(11):
theta_table[1 << i] = Mat24Tables.vect_to_cocode(thetas[i])
for i in range(0x800):
if (i & (i-1)) != 0: # i.e. if i is not 0 or a power of 2
i0 = 1 << v2(i)
i1 = i ^ i0
cap = Mat24Tables.gcode_to_vect(i0)
cap &= Mat24Tables.gcode_to_vect(i1)
cc = Mat24Tables.vect_to_cocode(cap)
theta_table[i] = theta_table[i0] ^ theta_table[i1] ^ cc
return theta_table
def lsbit24(x):
return v2(x | 0x1000000)
def lsbit24(x):
"""Return position of least significant bit of (x & 2**24)"""
return v2(x | 0x1000000)