def test_all_random_io(verbose=0):
print("Chisquare test for randomization of an mm vector")
for i in range(2):
to_sparse = 0 if i else 1
for p in characteristics():
do_test_random_io(p, verbose, to_sparse)
print("Test passed")
def test_sym_all(verbose=0):
print("Test io operations for tags ABC")
for tag in "ABC":
for p in characteristics():
do_test_sym_io(p, tag, verbose=verbose)
do_test_sym_io_bad(p, tag, verbose=verbose)
print("Test passed")
def test_ABC(n_cases):
for p in characteristics():
sp = space(p)
for _ in range(n_cases):
i1 = i0 = randint(0, 23)
while i1 == i0:
i1 = randint(0, 23)
scalar = randint(1, p-1) + p * randint(-5, 5)
for tag in "ABC":
c0 = Cocode([i0])
c1 = Cocode([i1])
v0 = GcVector([i0])
v1 = GcVector([i1])
ref = sp(tag, i0, i1)
for j0 in [i0, c0, v0]:
for j1 in [i1, c1, v1]:
assert sp(tag, j0, j1) == ref
mmv = sp()
mmv[tag, j0, j1] = scalar
assert mmv == scalar * ref
assert mmv[tag, j0, j1] == scalar % p
def test_T(n_cases):
for p in characteristics():
sp = space(p)
for _ in range(n_cases):
o = randint(0, 758)
so = randint(0, 63)
coc = Cocode(SubOctad(o, so))
v = GcVector (coc.syndrome(randint(0,23)))
sgn = randint(0, 1)
pl = PLoopZ(sgn) * Octad(o)
gc = GCode(pl)
scalar = randint(1, p-1) + p * randint(-5, 5)
assert gc == GCode(pl)
ref = (-1)**sgn * sp('T', o, so)
for sign, d in ((sgn,o), (sgn,gc), (0, pl)):
for par2 in (so, coc, v):
assert (-1)**sign * sp('T', d, par2) == ref
mmv = sp()
mmv['T', d, par2] = (-1)**sign * scalar
assert mmv == scalar * ref
signed_scalar = (-1)**sign * scalar % p
assert mmv['T', d, par2] == signed_scalar
def test_AD(n_cases):
for p in characteristics():
sp = space(p)
for _ in range(n_cases):
i0 = randint(0, 23)
scalar = randint(1, p-1) + p * randint(-5, 5)
c0 = Cocode([i0])
v0 = GcVector([i0])
ref = sp('A', i0, i0)
for j0 in [i0, c0, v0]:
for j1 in [i0, c0, v0]:
assert sp('A', j0, j1) == ref
mmv = sp()
mmv['A', j0, j1] = scalar
assert mmv == scalar * ref
assert mmv['A', j0, j1] == scalar % p
d1 = sp('D', j0)
assert sp('D', j0) == ref
mmv = sp()
mmv['D', j0] = scalar
assert mmv == scalar * ref
assert mmv['D', j0] == scalar % p
def test_XYZ(n_cases):
for p in characteristics():
sp = space(p)
for _ in range(n_cases):
d = randint(0, 0x1fff)
i = randint(0, 23)
c = Cocode([i])
v = GcVector([i])
pl = PLoop(d)
gc = GCode(d & 0xfff)
d0 = d & 0x7ff
scalar = randint(1, p-1) + p * randint(-5, 5)
for tag in "XYZ":
s2 = s1 = d >> 12
if tag == "Y": s1 ^= d >> 11
ref = (-1)**s1 * sp(tag, d0, i)
for sign, dd in ((s1, d0), (s2, gc), (0, pl)):
for j in [i, c, v]:
assert (-1)**sign * sp(tag, dd, j) == ref
mmv = sp()
mmv[tag, dd, j] = (-1)**sign * scalar
assert mmv == scalar * ref
signed_scalar = (-1)**sign * scalar % p
assert mmv[tag, dd, j] == signed_scalar
from mmgroup.mm_space import characteristics
from mmgroup.mm import mm_aux_index_sparse_to_extern
from mmgroup.mm import mm_aux_index_extern_to_sparse
from mmgroup.mm import mm_aux_mmv_extract_sparse
from mmgroup.tests.spaces.spaces import MMTestSpace
from mmgroup.tests.spaces.sparse_mm_space import SparseMmV
from mmgroup.tests.groups.mgroup_n import MGroupNWord
#from mm_vector import FastMmRepSpace, PRIMES
#from mm_vector import SparseMmRepVector
#from mm_vector import AbstractRepVector
#from mm_vector import mm_sparse_purge
#from mm_vector import basis_vectors_to_sparse
PRIMES = characteristics()
np.set_printoptions(formatter={'int': hex})
########################################################################
# group_blocks
########################################################################
"""Finding blocks in the matrix of an element g of the monster
Let R be the representation of the monster Mm and let g in Mm. We want
to test the fast C implementation of the operation of g against the
slow python implementation. While the C implementation always operates
on a vector v in R of full length, the python implementation works on
the individual components ov v, with run time depending on the number
of componennts of v. So we select a uniform random vector v and an
atom of the group g and we let the C implementation of g operate of v.
import sys
import os
import time
sys.path.insert(0, os.path.abspath("src"))
#print(sys.path)
print("Importing python dlls..")
t_start = time.time()
import mmgroup
from mmgroup import mat24
from mmgroup import generators
from mmgroup import mm
print("Importing python for specific characteristics..")
from mmgroup.mm_space import characteristics
pp = characteristics()
t = time.time() - t_start
print("done after %.2f seconds." % t)
s = "Representations of the Monster modulo %s are supported."
print(s % ", ".join(map(str, pp)))
def test_large_all(verbose=0):
print("Test io operations for tags TXYZ")
for tag in "TXYZ":
for p in characteristics():
do_test_large_io(p, tag, verbose=verbose)
print("Test passed")
try:
from mmgroup.structures.mm0_group import MM0Group, MM0
except:
w = "Class mmgroup.structures.MM0 not found, package not functional!"
warnings.warn(w, UserWarning)
try:
import mmgroup.mm_group
from mmgroup.mm_group import MMGroup, MM
except:
w = "Class mmgroup.MM not found, package not functional!"
warnings.warn(w, UserWarning)
import mmgroup.generate_c
try:
import mmgroup.mm_space
from mmgroup.mm_space import characteristics
assert 3 in characteristics()
from mmgroup.mm_space import MMSpace, MMVector, MMV, order_vector
except:
w = "Extension mmgroup.mm3 not found, package not functional!"
warnings.warn(w, UserWarning)
try:
from mmgroup.structures.xsp2_co1 import Xsp2_Co1
except:
w = "Module 'mmgroup.structures.xsp2_co1' not found!"
warnings.warn(w, UserWarning)
