def generate_fc(init_positions=None,
n_fc=None,
radius_fc=None,
color=(80, 120, 50, 128)):
"""Generar Femto celdas
:param init_positions: posiciones iniciales
:param n_fc: número de femtoceldas
:param radius_fc: radio de femtocelda
:param color: tuple color for femtocells
:return:
"""
if not isinstance(init_positions, np.ndarray):
init_positions = np.array(init_positions)
fcs = Group(prefix="F") # Grupo de femtoceldas
m, n, _ = init_positions.shape
space_between_fc = 4
indx = 0
pos_y = [i for i in range(m) if i % 4 == 0]
pos_x = [i + 1 for i in range(n) if i % 4 == 0]
for i in pos_x:
for j in pos_y:
if indx < n_fc:
position = init_positions[j + 1, i]
fcs.add(
Femtocell(*position,
radius=radius_fc,
color=color,
Id="FC" + str(indx + 1),
indx=indx))
indx += 1
return fcs
def run(this, points):
points = points.getNext().values
size = len(points)
scales = binomials(size)
out = Group()
for i in range(this.numPoints):
t = i / (this.numPoints - 1.0)
tt = 1 - t
pos = [0, 0, 0]
tan = [0, 0, 0]
for j in range(size):
top = size - j - 1
scale = scales[j] * math.pow(t, j) * math.pow(tt, top)
tanScale = 0
if j > 0:
tanScale += j * math.pow(t, j - 1) * math.pow(tt, top)
if j < size - 1:
tanScale += (size - j - 1) * math.pow(t, j) * math.pow(tt, top - 1)
tanScale *= scales[j]
pos = [pos[0] + scale * points[j][0], pos[1] + scale * points[j][1],
pos[2] + scale * points[j][2]]
tan = [tan[0] + tanScale * points[j][0],
tan[1] + tanScale * points[j][1],
tan[2] + tanScale * points[j][2]]
out.addVector(pos)
out.addTangent(tan)
return out
def test_orbits4(self):
self.N = 10
self.group = Group()
self.group.insert(Perm()(0, 1, 2))
self.assertFalse(self.group.is_transitive(points=range(self.N)))
self.assertTrue(
self.group.is_transitive(strict=False, points=range(self.N)))
def generate_cars(init_positions=None,
n_cars=None,
color=(20, 160, 140, 100),
radius_car=16,
map_size=None,
d2d=True):
"""Genera los autos
:param init_positions: vector de posiciones iniciales
:param n_cars: número de autos
:param color: color de los autos
:param radius_car: radio de los autos
:param map_size: tamaño del mapa
:param d2d: D2D flag
:return:
"""
if map_size is None:
map_size = [1024, 720]
cars = Group(prefix="C") # Grupo de carros
rand_centers = random.sample(init_positions, n_cars)
i = 1
for position in rand_centers:
cars.add(
Car(x=position[0],
y=position[1],
Id="C" + str(i),
color=color,
radius=radius_car,
map_size=map_size,
d2d=d2d,
indx=i))
i += 1
return cars
def test_orbits2(self):
self.N = 4
self.group = Group()
self.group.insert(Perm()(0, 1))
self.group.insert(Perm()(2, 3))
self.assertFalse(self.group.is_transitive(points=range(self.N)))
self.assertEqual(self.group.orbits(range(self.N)), [[0, 1], [2, 3]])
self.assertEqual(self.group.orbits([0, 1]), [[0, 1]])
self.assertEqual(self.group.orbits([0, 1, 2]), [[0, 1], [2, 3]])
def test_orbits1(self):
self.N = 3
self.group = Group()
self.group.insert(Perm()(0, 1))
self.assertEqual(self.group.orbits(range(self.N)), [[0, 1], [2]])
self.assertEqual(self.group.orbits([0, 1]), [[0, 1]])
self.assertFalse(self.group.is_transitive(points=range(self.N)))
self.assertTrue(
self.group.is_transitive(points=range(self.N), strict=False))
def test_is_subgroup(self):
self.group2 = Group()
# Make cyclic group C_N.
self.group2.insert(Perm()(*range(self.N)))
self.assertEqual(self.group2.order(), self.N)
self.assertTrue(self.group2.is_subgroup(self.group1))
self.assertTrue(self.group2.is_abelian())
self.assertFalse(self.group1.is_abelian())
self.assertFalse(self.group2.is_normal(self.group1))
def run(this, group):
vectors = []
normals = []
for i in range(this.numGroups):
vectors.extend(group.getNext().vectors)
normals.extend(group.getCurrent().normals)
out = Group()
out.vectors = vectors
out.normals = normals
return out
def test_centralizer(self):
# Tworze grupe cykliczna.
self.group2 = Group()
self.group2.insert(Perm()(*range(self.N)))
self.assertEqual(self.group2.order(), self.N)
# centrum grupy abelowej cyklicznej to cala grupa
self.group3 = self.group2.center()
self.assertEqual(self.group3.order(), self.N)
# Dalej dla grupy symetrycznej.
self.group2 = self.group1.center()
self.assertEqual(self.group2.order(), 1)
def do_work(fd_vcf, tsv_pheno, tsv_haplo):
vcf = Vcf(fd_vcf)
vcf.load_meta_header()
grps_pheno, grps_haplo = Group(tsv_pheno), Group(tsv_haplo)
matrix, a_sites, a_groups = prepare(vcf, grps_pheno, grps_haplo)
print matrix.shape
print a_groups
#values = np.random.randn(100,100) * 10
#a_sites = ['1_100', '2_200', '3_300']
#a_groups = ['grp1', 'grp1', 'grp2']
cb_labels = ['HETE', 'HOMO_VAR', 'OTHER', 'NO_COVERAGE', 'HOMO_REF']
drdplots.Heatmap(matrix, cb_labels, a_sites, a_groups).plot()
def __init__(self, name, load=True):
#Added
self.users = {}
self.groups = {}
self.loggedInAs = None
all_privs = {'Create_User': True, 'Delete_Tbl': True}
#admin
admin = User('admin', 'admin', all_privs, set(), set())
self.users.update({'admin': admin})
self.loggedInAs = admin
#groups
admin_group = Group('admins', {
'Create_User': True,
'Delete_Tbl': True
}, set(), set())
self.groups.update({'admins': admin_group})
viewer_group = Group('admins', {}, set(), set())
self.groups.update({'viewers': viewer_group})
#Added
self.tables = {}
self._name = name
self.savedir = f'dbdata/{name}_db'
if load:
try:
self.load(self.savedir)
print(f'Loaded "{name}".')
return
except:
print(f'"{name}" db does not exist, creating new.')
# create dbdata directory if it doesnt exist
if not os.path.exists('dbdata'):
os.mkdir('dbdata')
# create new dbs save directory
try:
os.mkdir(self.savedir)
except:
pass
# create all the meta tables
self.create_table('meta_length', ['table_name', 'no_of_rows'],
[str, int])
self.create_table('meta_locks', ['table_name', 'locked'], [str, bool])
self.create_table('meta_insert_stack', ['table_name', 'indexes'],
[str, list])
self.create_table('meta_indexes', ['table_name', 'index_name'],
[str, str])
self.save()
def merge_tests(existing_tests, incoming_tests):
"""Given two sets of tests, merge the incoming tests into
the existing tests."""
# The merge will take the following steps:
# - already seen tests will only have "opt/debug_status" updated
# - newly failing tests will be added under the appropriate component
# - tests that are no longer failing will be marked as "passes" rather
# than be removed from the resulting set
# - tests that were already marked as "passes" and still pass in a
# subsequent run of the script will be removed from the result set
newly_failing, newly_passing, passing_removed = [], [], []
not_seen_group = set(existing_tests.keys())
def handle_passing_tests(group_name, not_seen):
for test_name in list(not_seen): # leftover tests are no longer failing/skipped
if existing_tests[group_name].tests[test_name].opt_status == 'passes' and \
existing_tests[group_name].tests[test_name].debug_status == 'passes':
existing_tests[group_name].tests.pop(test_name)
passing_removed.append(test_name)
else:
existing_tests[group_name].tests[test_name].opt_status = 'passes'
existing_tests[group_name].tests[test_name].debug_status = 'passes'
newly_passing.append(test_name)
for group_name, incoming_group in incoming_tests.items():
not_seen_group.discard(group_name)
if group_name not in existing_tests:
existing_tests[group_name] = Group(group_name, [])
not_seen = set(existing_tests[group_name].tests.keys())
for test_name, new_test in incoming_group.tests.items():
if new_test.name in not_seen: # test exists, so update fields
for attr in ['opt_status', 'debug_status', 'xorig_and_fis', 'xorig_and_not_fis']:
setattr(existing_tests[group_name].tests[test_name], attr, getattr(new_test, attr))
not_seen.discard(test_name)
else: # new test
existing_tests[group_name].tests[test_name] = new_test
newly_failing.append(test_name)
handle_passing_tests(group_name, not_seen)
if len(existing_tests[group_name].tests) == 0:
existing_tests.pop(group_name)
for group_name in list(not_seen_group):
handle_passing_tests(group_name, existing_tests[group_name].tests)
existing_tests.pop(group_name)
return existing_tests, newly_failing, newly_passing, passing_removed
def main():
root = tk.Tk()
root.geometry('890x680+120+50')
root.resizable(width=False, height=False)
groups = [
Group('变电所变电所aaa' + str(i), '主经路主aaabbbb' + str(i),
'分支线路分支线路支线路' + str(i), '群名称群名称名称aaaaaa' + str(i))
for i in range(60)
]
templates = [
Template('Temp' + str(i), 'Content Content ContentContent ' + str(i))
for i in range(3)
]
class WxBot:
pass
wxbot = WxBot()
wxbot.self = WxBot()
wxbot.self.name = '姜'
frame = MainFrame(root, wxbot, groups, templates)
frame.pack()
# tk.Button(root, text='获取选择的群', command=lambda: print(gframe.get_selected())).pack()
# tk.Button(root, text='search', command=lambda: print(gframe.search(keyword='1'))).pack()
tk.mainloop()
def generate_groups(img):
#give each component a different integer label in the output matrix
labeled_img = np.zeros(img.shape)
#all ones --> 8 connectivity (use cross shape for 4 connectivity)
struct = np.ones((3, 3))
n_features = label(img, structure=struct, output=labeled_img)
groups_by_label = {}
groups = []
#use labels to put pixels into groups
for y in range(len(img)):
for x in range(len(img[0])):
#foreground pixels
if img[y][x]:
curr_label = labeled_img[y][x]
#create the group if it does not yet exist
if curr_label not in groups_by_label:
groups_by_label[curr_label] = Group(curr_label)
groups.append(groups_by_label[curr_label])
groups_by_label[curr_label].add((y, x))
return groups
def get_tests_from_spreadsheet(service, spreadsheet_id, sheet_name):
"""Pulls down the latest copy of an existing Google sheet and
generates a list of Groups."""
res = service.spreadsheets().values().get(spreadsheetId=spreadsheet_id,
range=sheet_name).execute()
test_map = Group.from_csv_spreadsheet(res['values'])
return test_map # Used for generating 'existing_tests'
def add_group(
chain_map: Dict[Group, list],
group_name: str,
charge: int,
atoms: Set[int],
) -> None:
default = GroupsData.DEFAULTS[group_name]
if ignore_protonations:
chain_map[default].append(atoms)
else:
# NOTE(flamholz): We rely on the default number of
# magnesiums being 0 (which it is).
hydrogens = default.hydrogens + charge - default.charge
group = Group(group_name, hydrogens, charge, default.nMg)
if group not in chain_map:
# logging.warning('This protonation (%d) level is not
# allowed for terminal phosphate groups.' % hydrogens)
# logging.warning('Using the default protonation level (
# %d) for this name ("%s").' % (default.hydrogens,
# default.name))
raise GroupDecompositionError(
f"The group {group_name} cannot have nH = {hydrogens}"
)
# chain_map[default].append(atoms)
else:
chain_map[group].append(atoms)
def test_is_normal(self):
a = Perm()(0, 1, 2)
b = Perm()(0, 1)
c = Perm()(0, 2, 1)
G = Group()
G.insert(a)
G.insert(b)
self.assertEqual(G.order(), 6) # G = S_3
H = Group()
H.insert(a)
H.insert(c)
self.assertEqual(H.order(), 3) # H = A_3
self.assertTrue(H.is_normal(G))
def run(this, frames):
if this.lastFrame is None:
this.lastFrame = frames.getNext()
thisFrame = frames.getNext()
out = Group()
for i in range(min(len(thisFrame.values), len(this.lastFrame.values))) + [0]:
out.addVector(this.lastFrame.values[i])
out.addNormal(this.lastFrame.values[i])
out.addVector(thisFrame.values[i])
out.addNormal(thisFrame.values[i])
this.lastFrame = thisFrame
return out
def test_is_subgroup(self):
self.group2 = Group()
# Tworze grupe cykliczna.
self.group2.insert(Perm()(*range(self.N)))
self.assertTrue(self.group2.is_subgroup(self.group1))
self.assertTrue(self.group2.is_abelian())
self.assertFalse(self.group1.is_abelian())
self.assertFalse(self.group2.is_normal(self.group1))
def test_groupAdd_shouldReturnNewGroupWithAllPeople(self):
person_3 = Person('George', 'Francis')
group_2 = Group('test2', [person_3])
new_group = self.group + group_2
self.assertEqual(new_group.people, [self.person_1, self.person_2, person_3])
self.assertEqual(new_group.name, 'test')
def do_work(fd_vcf, csv):
vcf = Vcf(fd_vcf)
vcf.load_meta_header()
grps = Group(csv)
#sys.stderr.write("# Of groups loaded: %s\n" % grps.num())
min_threshold = float(sys.argv[2])
min_num_all = float(sys.argv[3])
ComputeSnps(vcf, grps, min_threshold, min_num_all).run()
def test_orbits1(self):
self.N = 3
self.group = Group()
self.group.insert(Perm()(0,1))
self.assertEqual(self.group.orbits(range(self.N)), [[0, 1],[2]])
self.assertEqual(self.group.orbits([0, 1]), [[0, 1]])
self.assertFalse(self.group.is_transitive(points=range(self.N)))
self.assertTrue(self.group.is_transitive(points=range(self.N), strict=False))
def test_is_subgroup(self):
self.group2 = Group()
# Make cyclic group C_N.
self.group2.insert(Perm()(*range(self.N)))
self.assertEqual(self.group2.order(), self.N)
self.assertTrue(self.group2.is_subgroup(self.group1))
self.assertTrue(self.group2.is_abelian())
self.assertFalse(self.group1.is_abelian())
self.assertFalse(self.group2.is_normal(self.group1))
class Database:
'''
Database class contains tables.
'''
#Add
self.users = {}
self.groups = {}
self.loggedInAs = None
all_privs = {'Create_User' : True, 'Delete_Tbl' : True}
#admin
admin = User('admin', 'admin', all_privs, set(), set())
self.users.update({'admin': admin})
self.loggedInAs = admin
#groups
admin_group = Group('admins', {'Create_User' : True, 'Delete_Tbl' : True}, set(), set())
self.groups.update({'admins': admin_group})
viewer_group = Group('admins', {}, set(), set())
self.groups.update({'viewers': viewer_group})
def test_orbits2(self):
self.N = 4
self.group = Group()
self.group.insert(Perm()(0, 1))
self.group.insert(Perm()(2, 3))
self.assertFalse(self.group.is_transitive(points=range(self.N)))
self.assertEqual(self.group.orbits(range(self.N)), [[0, 1],[2, 3]])
self.assertEqual(self.group.orbits([0, 1]), [[0, 1]])
self.assertEqual(self.group.orbits([0, 1, 2]), [[0, 1],[2, 3]])
def test_group_adding(self):
p0 = Person('Aliko', 'Dangote')
p1 = Person('Bill', 'Gates')
second_group = Group("Second", [p0, p1])
third = self.first_group + second_group
expected_name = self.first_group.name
self.assertEqual(third.name, expected_name)
expected_len = len(self.first_group) + len(second_group)
self.assertEqual(len(third), expected_len)
def merge_groups(groups, dist_tol):
""" Merges untill all groups have at least
`dist_tol` distance between them
Parameters
----------
groups :obj:list of `Group`
groups found using adjacency
dist_tol : int
minimum euclidean distance
to be in same cluster
Returns
-------
:obj:list of `Group`
"""
#give groups initial labels = indexes
for i in range(len(groups)):
groups[i].updateLabel(i)
uf = UnionFind(len(groups))
#find labels to merge
for i in range(len(groups)):
curr_group = groups[i]
#only look at groups farther in list
for j in range(i, len(groups)):
other_group = groups[j]
#short circuit if already connected (minimize nearest neighbor calls)
if not uf.find(curr_group.label, other_group.label):
if Group.nearby(curr_group, other_group, dist_tol):
uf.union(curr_group.label, other_group.label)
merged_groups = []
unmerged_groups = []
#iterate until all merges have been made
while len(groups) > 0:
curr_group = groups[0]
merged_groups.append(curr_group)
for j in range(1, len(groups)):
other_group = groups[j]
#on each iteration, one merged group moves to the new array
if uf.find(curr_group.label, other_group.label):
curr_group.merge(other_group)
#all other groups are kept in the old array
else:
unmerged_groups.append(other_group)
groups = unmerged_groups
unmerged_groups = []
for g in merged_groups:
g.compute_info()
return merged_groups
def test_centralizer(self):
# Tworze grupe cykliczna.
self.group2 = Group()
self.group2.insert(Perm()(*range(self.N)))
self.assertEqual(self.group2.order(), self.N)
# centrum grupy abelowej cyklicznej to cala grupa
self.group3 = self.group2.center()
self.assertEqual(self.group3.order(), self.N)
# Dalej dla grupy symetrycznej.
self.group2 = self.group1.center()
self.assertEqual(self.group2.order(), 1)
def logic(self):
nr_containers = totContainers()
port = Port("PiraeusPier2", nr_containers)
threads = []
groups = []
nr_groups = 13
colours = []
colours.append(pygame.Color(228, 197, 73))
colours.append(pygame.Color(185, 0, 37))
colours.append(pygame.Color(78, 87, 111))
colours.append(pygame.Color(12, 63, 50))
colours.append(pygame.Color(236, 110, 0))
colours.append(pygame.Color(68, 22, 33))
colours.append(pygame.Color(143, 149, 160))
colours.append(pygame.Color(185, 197, 201))
colours.append(pygame.Color(35, 127, 125))
colours.append(pygame.Color(149, 132, 103))
colours.append(pygame.Color(0, 44, 125))
colours.append(pygame.Color(0, 160, 213))
colours.append(pygame.Color(166, 202, 87))
colours.append(pygame.Color(228, 166, 156))
for i in range(nr_groups - port.nr_docks):
groups.append(Group(i, port, "outbound", nr_containers,
colours[i]))
for i in range(nr_groups - port.nr_docks, nr_groups):
groups.append(Group(i, port, "inbound", nr_containers, colours[i]))
info = InfoPanel(port, groups)
for i in range(nr_groups):
thread = Thread(target=groups[i].manage, name=str(i), daemon=True)
threads.append(thread)
"""info = Thread(target = info.give_info, name = str(nr_groups + 1), daemon = True)
threads.append(info)"""
for t in threads:
t.start()
graphics = Graphics(port, groups)
graphics.display()
while True:
pass
def get_tests_from_report(report):
"""Loads tests from a json report (ie './mach test-info report ...')"""
if type(report) == 'str':
with open(report) as f:
data = json.load(f)['tests']
else:
data = report.get('tests')
test_map = {}
for group, subtests in data.items():
g = Group(group, subtests)
test_map[group] = g
return test_map # Used for generating 'incoming_tests'
def create_group(self, name, privs, del_privs, sel_privs):
if self.loggedInAs.can_create():
del_privileges = dict()
sel_privileges = dict()
for priv in del_privs:
del_privileges.update({priv: True})
for priv in sel_privs:
sel_privileges.update({priv: True})
self.groups.update({name: Group(name, privs, del_privileges, sel_privileges)})
print("{g} Group has been created".format(g=name))
else:
print("You don't have the privileges to create a new Group")
def build_city(width=1280, height=720, edificesColor=(10, 200, 50)):
"""Contruye una ciudad con edificios
Args:
"""
# Para construir la Ciudad
D = 8 # Separación entre calles (px)
w = 51 # Ancho de los edificiós (px)
h = 51 # Largo (altura rectangular) de los edificios (px)
W = 1024 # Ancho del mapa (px)
H = 720 # Largo del mapa (px)
# Calcular número de edificios
m = int(W / w) # ¿Cuántos edificios caben a lo ancho del mapa?
n = int(H / h) # ¿Cuántos edificios caben a lo largo del mapa?
edifices = Group(prefix="Edifice") # Grupo de paredes
centers_corner = [] # Esquina
centers_street = [] # Centro calle
offset_x = 5
offset_y = 5
rows = []
# Contruir ciudad
for i in range(m):
for j in range(n):
x = int(i * w + offset_x)
y = int(j * h + offset_y)
edifices.add(Edifice(x, y, w - D, h - D, color=edificesColor))
rows.append([x + w, y + h])
centers_street.append([x + w - int(D / 2), y + h - int(D / 2)])
centers_corner.append(rows)
rows = []
# centers_corner = np.array(centers_corner, dtype='uint8')
centers_corner = np.array(centers_corner)
return edifices, centers_corner, centers_street
def generate_groups(img, orig_shape, scaled_shape):
""" Finds groups using adjacency
(dist_tol = 0)
Parameters
----------
img :obj:`numpy.ndarray`
binary foreground image
orig_shape : tuple
shape of 2D image before scaling down
scaled_shape : tuple
shape of 2D image after scaling down
Returns
-------
:obj:list of `Group`
"""
#give each component a different integer label in the output matrix
labeled_img = np.zeros(img.shape)
#all ones --> 8 connectivity (use cross shape for 4 connectivity)
struct = np.ones((3, 3))
n_features = label(img, structure = struct, output = labeled_img)
groups_by_label = {}
groups = []
#use labels to put pixels into groups
for y in range(len(img)):
for x in range(len(img[0])):
#foreground pixels
if img[y][x]:
curr_label = labeled_img[y][x]
#create the group if it does not yet exist
if curr_label not in groups_by_label:
groups_by_label[curr_label] = Group(curr_label, orig_shape, scaled_shape)
groups.append(groups_by_label[curr_label])
groups_by_label[curr_label].add((y, x))
return groups
def merge_groups(groups, tol):
#give groups initial labels = indexes
for i in range(len(groups)):
groups[i].updateLabel(i)
uf = UnionFind(len(groups))
#find labels to merge
for i in range(len(groups)):
curr_group = groups[i]
#only look at groups farther in list
for j in range(i, len(groups)):
other_group = groups[j]
#short circuit if already connected (minimize nearest neighbor calls)
if not uf.find(curr_group.label, other_group.label):
if Group.nearby(curr_group, other_group, tol):
uf.union(curr_group.label, other_group.label)
merged_groups = []
unmerged_groups = []
#iterate until all merges have been made
while len(groups) > 0:
curr_group = groups[0]
merged_groups.append(curr_group)
for j in range(1, len(groups)):
other_group = groups[j]
#on each iteration, one merged group moves to the new array
if uf.find(curr_group.label, other_group.label):
curr_group.merge(other_group)
#all other groups are kept in the old array
else:
unmerged_groups.append(other_group)
groups = unmerged_groups
unmerged_groups = []
return merged_groups
def main():
root = tk.Tk()
root.geometry('600x720+120+50')
root.resizable(width=False, height=False)
groups = [
Group('变电所变电所' + str(i % 10), '主经路主经路' + str(i % 20),
'分支线路支线路' + str(i % 50), '台区台区台区台区', '群名称群名称' + str(i))
for i in range(500)
]
bdz_dict, zxl_dict, fzxl_dict, tq_dict = parse_group_dict(groups)
gframe = GroupFrame(root, groups)
sframe = SearchFrame(root, bdz_dict, zxl_dict, fzxl_dict, gframe)
print(bdz_dict)
print(zxl_dict)
print(fzxl_dict)
sframe.pack()
gframe.pack()
# tk.Button(root, text='获取选择的群', command=lambda:print(gframe.get_selected())).pack()
# tk.Button(root, text='search', command=lambda:print(gframe.search(keyword='1'))).pack()
tk.mainloop()
class GroupTest(unittest.TestCase):
def setUp(self):
p0 = Person('Aliko', 'Dangote')
p1 = Person('Bill', 'Gates')
p2 = Person('Warren', 'Buffet')
self.first_group = Group('__VIP__', [p0, p1, p2])
def test_group_init(self):
self.assertEqual(self.first_group.name, '__VIP__')
self.assertEqual(self.first_group.people[0].name, 'Aliko')
def test_group_len_linst_people(self):
self.assertEqual(len(self.first_group.people), 3)
def test_group_print(self):
self.assertEqual(str(self.first_group),
'Group __VIP__ with members Aliko Dangote, '
'Bill Gates, Warren Buffet')
def test_group_item_print(self):
self.assertEqual(self.first_group.__getitem__(0), 'Person 0: Aliko Dangote')
def test_group_item_print_with_for_cycle(self):
expected = ['Person 0: Aliko Dangote','Person 1: Bill Gates',
'Person 2: Warren Buffet']
self.assertEqual(list(self.first_group), expected) # list involes iter() method under the hood
def test_group_adding(self):
p0 = Person('Aliko', 'Dangote')
p1 = Person('Bill', 'Gates')
second_group = Group("Second", [p0, p1])
third = self.first_group + second_group
expected_name = self.first_group.name
self.assertEqual(third.name, expected_name)
expected_len = len(self.first_group) + len(second_group)
self.assertEqual(len(third), expected_len)
def addGroup(self, name):
grp = Group(None)
grp.name = name
self.groups.append(grp)
def result_to_group(self,result):
#id=result[0]
grp = Group(result[2],result[1])
grp.groupID = result[0]
return grp
# Import the class Group from the file groups.py
from groups import Group
# Create an instance of the group (5,+)x(9,x)
print("Create a group (5,+)x(9,x)")
G = Group(["add", "mult"], [5, 9])
# print the group components
Gg = G.g("show")
g3 = G.g(3)
print("Element 3 = ", G.g(3))
print("Inverse of element 3 = ", G.inv(g3))
g7 = G.g(7)
g6 = G.g(6)
print("Element 7 = ", g7)
print("Element 6 = ", g6)
print("Multiplication of element 7 and element 6 = ", G.op(g7, g6))
print("Element 7 to the power of 3 = ", G.pow(g7, 3))
print("Group orders:")
Gg = G.g()
Ggo = G.go()
for (g, go) in zip(Gg, Ggo):
print("Element ", g, " has order ", go)
def setUp(self):
self.N = 4
# Tworze grupe symetryczna.
self.group1 = Group()
self.group1.insert(Perm()(0, 1))
self.group1.insert(Perm()(*range(self.N)))
# Importing require modules
from groups import Group
from pure import setCrossProd
# Creating group and subgroup
print("Create (120,+)")
G = Group("add", 120)
G.g("show")
GS = G.sub([15, 30, 60])
# print the sub group components
GSg = GS.g()
GS.g("show")
print("Inverse of element 15 = ", GS.inv(15))
print("Multiplication of 15 and 30 = ", GS.op(15, 30))
print("15 to the power 3 = ", GS.pow(15, 3))
GSgo = GS.go()
for g, go in zip(GSg, GSgo):
print("Element: ", g, " has order: ", go)
# Import the class Group from the file groups.py
from groups import Group
# Create an instance of the group (10,+)
G = Group("add", 10)
# print the group elements
G.g("show")
# Create an instance of the group (15,x)
H = Group("mult", 15)
# print the group elements
H.g("show")
def test_normal_closure(self):
n = 5
# Tworze grupe cykliczna C_5.
C5 = Group()
C5.insert(Perm()(*range(n)))
self.assertEqual(C5.order(), n)
# Make Sym(5).
S5 = Group()
S5.insert(Perm()(*range(n)))
S5.insert(Perm()(0, 1))
self.assertEqual(S5.order(), 120)
A5 = S5.normal_closure(C5)
self.assertEqual(A5.order(), 60)
for perm in A5.iterperms():
self.assertTrue(perm.is_even())
class TestGroupOrbits(unittest.TestCase):
def setUp(self): pass
def test_orbits1(self):
self.N = 3
self.group = Group()
self.group.insert(Perm()(0,1))
self.assertEqual(self.group.orbits(range(self.N)), [[0, 1],[2]])
self.assertEqual(self.group.orbits([0, 1]), [[0, 1]])
self.assertFalse(self.group.is_transitive(points=range(self.N)))
self.assertTrue(self.group.is_transitive(points=range(self.N), strict=False))
def test_orbits2(self):
self.N = 4
self.group = Group()
self.group.insert(Perm()(0, 1))
self.group.insert(Perm()(2, 3))
self.assertFalse(self.group.is_transitive(points=range(self.N)))
self.assertEqual(self.group.orbits(range(self.N)), [[0, 1],[2, 3]])
self.assertEqual(self.group.orbits([0, 1]), [[0, 1]])
self.assertEqual(self.group.orbits([0, 1, 2]), [[0, 1],[2, 3]])
def test_orbits3(self): # grupa cykliczna
self.N = 10
self.group = Group()
self.group.insert(Perm()(*range(self.N)))
self.assertTrue(self.group.is_transitive(points=range(self.N)))
def test_orbits4(self):
self.N = 10
self.group = Group()
self.group.insert(Perm()(0, 1, 2))
self.assertFalse(self.group.is_transitive(points=range(self.N)))
self.assertTrue(self.group.is_transitive(strict=False, points=range(self.N)))
def tearDown(self): pass
def setUp(self):
self.N = 4
# Make symmetric group S_N.
self.group1 = Group()
self.group1.insert(Perm()(0, 1))
self.group1.insert(Perm()(*range(self.N)))
class TestSubgroup(unittest.TestCase):
def setUp(self):
self.N = 4
# Make symmetric group S_N.
self.group1 = Group()
self.group1.insert(Perm()(0, 1))
self.group1.insert(Perm()(*range(self.N)))
def test_subgroup_search(self):
self.assertEqual(self.group1.order(), 24)
# Dopuszczam permutacje parzyste - grupa alternujaca A_N.
self.group2 = self.group1.subgroup_search(lambda x: x.is_even())
self.assertEqual(self.group2.order(), 12)
self.assertTrue(self.group2.is_transitive(points=range(self.N)))
#print self.group2
def test_stabilizer(self):
self.group2 = self.group1.stabilizer(3)
self.assertEqual(self.group2.order(), 6)
#print self.group2
def test_centralizer(self):
# Tworze grupe cykliczna.
self.group2 = Group()
self.group2.insert(Perm()(*range(self.N)))
self.assertEqual(self.group2.order(), self.N)
# centrum grupy abelowej cyklicznej to cala grupa
self.group3 = self.group2.center()
self.assertEqual(self.group3.order(), self.N)
# Dalej dla grupy symetrycznej.
self.group2 = self.group1.center()
self.assertEqual(self.group2.order(), 1)
def test_normalizer(self):
pass
def test_normal_closure(self):
n = 5
# Tworze grupe cykliczna C_5.
C5 = Group()
C5.insert(Perm()(*range(n)))
self.assertEqual(C5.order(), n)
# Make Sym(5).
S5 = Group()
S5.insert(Perm()(*range(n)))
S5.insert(Perm()(0, 1))
self.assertEqual(S5.order(), 120)
A5 = S5.normal_closure(C5)
self.assertEqual(A5.order(), 60)
for perm in A5.iterperms():
self.assertTrue(perm.is_even())
def test_derived_subgroup(self):
pass
def test_is_subgroup(self):
self.group2 = Group()
# Make cyclic group C_N.
self.group2.insert(Perm()(*range(self.N)))
self.assertEqual(self.group2.order(), self.N)
self.assertTrue(self.group2.is_subgroup(self.group1))
self.assertTrue(self.group2.is_abelian())
self.assertFalse(self.group1.is_abelian())
self.assertFalse(self.group2.is_normal(self.group1))
def test_is_normal(self):
a = Perm()(0, 1, 2)
b = Perm()(0, 1)
c = Perm()(0, 2, 1)
G = Group()
G.insert(a)
G.insert(b)
self.assertEqual(G.order(), 6) # G = S_3
H = Group()
H.insert(a)
H.insert(c)
self.assertEqual(H.order(), 3) # H = A_3
self.assertTrue(H.is_normal(G))
def tearDown(self): pass
def test_orbits4(self):
self.N = 10
self.group = Group()
self.group.insert(Perm()(0, 1, 2))
self.assertFalse(self.group.is_transitive(points=range(self.N)))
self.assertTrue(self.group.is_transitive(strict=False, points=range(self.N)))
def test_orbits3(self): # grupa cykliczna
self.N = 10
self.group = Group()
self.group.insert(Perm()(*range(self.N)))
self.assertTrue(self.group.is_transitive(points=range(self.N)))
class TestSubgroup(unittest.TestCase):
def setUp(self):
self.N = 4
# Tworze grupe symetryczna.
self.group1 = Group()
self.group1.insert(Perm()(0, 1))
self.group1.insert(Perm()(*range(self.N)))
def test_subgroup_search(self):
self.assertEqual(self.group1.order(), 24)
# Dopuszczam permutacje parzyste - grupa alternujaca.
self.group2 = self.group1.subgroup_search(lambda x: x.is_even())
self.assertEqual(self.group2.order(), 12)
self.assertTrue(self.group2.is_transitive(points=range(self.N)))
#print self.group2
def test_stabilizer(self):
self.group2 = self.group1.stabilizer(3)
self.assertEqual(self.group2.order(), 6)
#print self.group2
def test_centralizer(self):
# Tworze grupe cykliczna.
self.group2 = Group()
self.group2.insert(Perm()(*range(self.N)))
self.assertEqual(self.group2.order(), self.N)
# centrum grupy abelowej cyklicznej to cala grupa
self.group3 = self.group2.center()
self.assertEqual(self.group3.order(), self.N)
# Dalej dla grupy symetrycznej.
self.group2 = self.group1.center()
self.assertEqual(self.group2.order(), 1)
def test_is_subgroup(self):
self.group2 = Group()
# Tworze grupe cykliczna.
self.group2.insert(Perm()(*range(self.N)))
self.assertTrue(self.group2.is_subgroup(self.group1))
self.assertTrue(self.group2.is_abelian())
self.assertFalse(self.group1.is_abelian())
self.assertFalse(self.group2.is_normal(self.group1))
def tearDown(self): pass
def run(this):
out = Group()
out.addVector((0.5, 0.5, 0.5))
out.addVector((-0.5, 0.5, 0.5))
out.addVector((-0.5, -0.5, 0.5))
out.addVector((0.5, -0.5, 0.5))
out.addNormal((0.0, 0.0, 1.0))
out.addVector((0.5, 0.5, -0.5))
out.addVector((0.5, -0.5, -0.5))
out.addVector((-0.5, -0.5, -0.5))
out.addVector((-0.5, 0.5, -0.5))
out.addNormal((0.0, 0.0, -1.0))
out.addVector((-0.5, 0.5, -0.5))
out.addVector((-0.5, -0.5, -0.5))
out.addVector((-0.5, -0.5, 0.5))
out.addVector((-0.5, 0.5, 0.5))
out.addNormal((-1.0, 0.0, 0.0))
out.addVector((0.5, 0.5, -0.5))
out.addVector((0.5, 0.5, 0.5))
out.addVector((0.5, -0.5, 0.5))
out.addVector((0.5, -0.5, -0.5))
out.addNormal((1.0, 0.0, 0.0))
out.addVector((0.5, -0.5, -0.5))
out.addVector((0.5, -0.5, 0.5))
out.addVector((-0.5, -0.5, 0.5))
out.addVector((-0.5, -0.5, -0.5))
out.addNormal((0.0, -1.0, 0.0))
out.addVector((0.5, 0.5, -0.5))
out.addVector((-0.5, 0.5, -0.5))
out.addVector((-0.5, 0.5, 0.5))
out.addVector((0.5, 0.5, 0.5))
out.addNormal((0.0, 1.0, 0.0))
return out
