def match(self, subjects, substitution):
subject_ids = Multiset()
pattern_ids = Multiset()
for subject in subjects:
subject_id, subject_pattern_ids = self.subjects[subject]
subject_ids.add(subject_id)
pattern_ids.update(subject_pattern_ids)
for pattern_index, pattern_set, pattern_vars in self.patterns.values():
if pattern_set:
if not pattern_set <= pattern_ids:
continue
bipartite_match_iter = self._match_with_bipartite(subject_ids, pattern_set, substitution)
for bipartite_substitution, matched_subjects in bipartite_match_iter:
if pattern_vars:
ids = subject_ids - matched_subjects
remaining = Multiset(self.subjects[id] for id in ids) # pylint: disable=not-an-iterable
sequence_var_iter = self._match_sequence_variables(
remaining, pattern_vars, bipartite_substitution
)
for result_substitution in sequence_var_iter:
yield pattern_index, result_substitution
elif len(subjects) == len(pattern_set):
yield pattern_index, bipartite_substitution
elif pattern_vars:
sequence_var_iter = self._match_sequence_variables(Multiset(subjects), pattern_vars, substitution)
for variable_substitution in sequence_var_iter:
yield pattern_index, variable_substitution
elif len(subjects) == 0:
yield pattern_index, substitution
def match(self, subjects: Sequence[Expression], substitution: Substitution) -> Iterator[Tuple[int, Substitution]]:
subject_ids = Multiset()
pattern_ids = Multiset()
if self.max_optional_count > 0:
subject_id, subject_pattern_ids = self.subjects[None]
subject_ids.add(subject_id)
for _ in range(self.max_optional_count):
pattern_ids.update(subject_pattern_ids)
for subject in op_iter(subjects):
subject_id, subject_pattern_ids = self.subjects[subject]
subject_ids.add(subject_id)
pattern_ids.update(subject_pattern_ids)
for pattern_index, pattern_set, pattern_vars in self.patterns.values():
if pattern_set:
if not pattern_set <= pattern_ids:
continue
bipartite_match_iter = self._match_with_bipartite(subject_ids, pattern_set, substitution)
for bipartite_substitution, matched_subjects in bipartite_match_iter:
ids = subject_ids - matched_subjects
remaining = Multiset(self.subjects_by_id[id] for id in ids if self.subjects_by_id[id] is not None)
if pattern_vars:
sequence_var_iter = self._match_sequence_variables(
remaining, pattern_vars, bipartite_substitution
)
for result_substitution in sequence_var_iter:
yield pattern_index, result_substitution
elif len(remaining) == 0:
yield pattern_index, bipartite_substitution
elif pattern_vars:
sequence_var_iter = self._match_sequence_variables(Multiset(op_iter(subjects)), pattern_vars, substitution)
for variable_substitution in sequence_var_iter:
yield pattern_index, variable_substitution
elif op_len(subjects) == 0:
yield pattern_index, substitution
def del_2(self, faces: List[Tuple[int]]):
"""
boundary of a list of faces, i.e. an arbitrary 2-chain over Z/2Z
"""
boundary_list = Multiset()
for face in faces:
boundary_list.update(Multiset(self.boundary_2(face)))
return boundary_list
def delta_1(self, stars: List[Tuple[int]]):
"""
coboundary of a list of stars, i.e. an arbitrary 0-cochain over Z/2Z
"""
coboundary_list = Multiset()
for star in stars:
coboundary_list.update(Multiset(self.boundary_1(star)))
return coboundary_list
def del_1(self, edges: List[Tuple[int]]):
"""
boundary of a list of edges, i.e. an arbitrary 1-chain over Z/2Z
"""
boundary_list = Multiset()
for edge in edges:
boundary_list.update(Multiset(self.boundary_1(edge)))
return boundary_list
def delta_2(self, edges: List[Tuple[int]]):
"""
coboundary of a list of edges, i.e. an arbitrary 1-cochain over Z/2Z
given by a list of cycles in alpha
"""
coboundary_list = Multiset()
for edge in edges:
coboundary_list.update(Multiset(self.boundary_1(edge)))
return coboundary_list
def test_correctness_randomized(self, variables, values):
values = Multiset(values)
for subst in commutative_sequence_variable_partition_iter(values, variables):
assert len(variables) == len(subst)
result_union = Multiset()
for var in variables:
assert len(subst[var.name]) >= var.minimum
result_union.update(subst[var.name] * var.count)
assert result_union == values
def pull(path):
if not path:
raise ValueError
m = Multiset()
with open(path) as f:
for line in f:
m.update(set(line.split(' ')))
return m
def __eval_add(element: Element, *args, **kwargs) -> Multiset:
if get_tag(element) != 'add':
raise Exception('Element is not an add operator!')
ms = Multiset()
for subterm in element:
constituent = eval_term(subterm, *args, **kwargs)
if not isinstance(constituent, Multiset):
raise Exception('Constituent of add must be a multiset!')
ms.update(constituent)
return ms
def multiply_units(*args):
this_units = Multiset()
for each_unit in args:
if get_unit_type(each_unit) == 'multiply':
this_units.update(get_complexunit_set(each_unit))
else:
this_units.add(each_unit)
if len(this_units) == 1:
return list(this_units)[0]
else:
return ('multiply', FrozenMultiset(this_units))
def test_correctness(self, variables, values, expected_iter_count):
values = Multiset(values)
variables = [VariableWithCount('var{:d}'.format(i), c, m, None) for i, (c, m) in enumerate(variables)]
count = 0
for subst in commutative_sequence_variable_partition_iter(values, variables):
assert len(variables) == len(subst), "Wrong number of variables in the substitution"
result_union = Multiset()
for var in variables:
assert len(subst[var.name]) >= var.minimum, "Variable did not get its minimum number of expressions"
result_union.update(subst[var.name] * var.count)
assert result_union == values, "Substitution is not a partition of the values"
count += 1
assert count == expected_iter_count, "Invalid number of substitution in the iterable"
def test_update(initial, add, result):
ms = Multiset(initial)
ms.update(*add)
assert sorted(ms) == result
assert len(ms) == len(result)
from multiset import Multiset
x = Multiset()
for i in range(10**10 + 1):
x.update(str(i))
if i % 10000000 == 0:
print(i)
for digit, count in x.items():
if count == i:
print(digit, i)
