def construct(self, zet):
if isinstance(zet, Intersection):
return self.common(map(self.construct, zet.args))
elif isinstance(zet, Union):
return self.fuse(map(self.construct, zet.args))
elif isinstance(zet, Complement):
return self.cut(*map(self.construct, zet.args))
elif isinstance(zet, Set):
return self._construct(zet)
else:
raise TypeError
def __new__(cls, ops):
ops = tuple(ops)
if not all(isinstance(op_i, ContinuousOperation) for op_i in ops):
raise TypeError
if len(set(map(thiz.distance, ops))) != 1:
raise ValueError
return TensorOperation.__new__(cls, ops)
def partial_fuse(self, col, glues=None, remain=True, err=False):
if glues is None:
return (self.fuse(col),)
targets, remaining = self.divide_into(col, glues, err=err)
fused = tuple(map(self.fuse, targets))
if remain:
fused = fused + tuple(remaining)
return fused
def simplify(self, col):
return tuple(filterfalse(self.is_null, map(self.simp, col)))
def partition_by(self, col, *objs):
knives = zip(objs, map(self.complement, objs))
return tuple(map(self.common, product(col, *knives)))
def cross_common(self, cols):
return tuple(map(self.common, product(*map(tuple, cols))))
def no_cross_collision(self, cols):
return all(map(self.no_collision, product(*map(tuple, cols))))
def __init__(self, acts):
diss = set(map(self.action_distance, self))
if len(diss) != 1:
raise ValueError
else:
self._distance = diss.pop()
def transform(self, pzl):
pzl = pzl.new(map(self.elem_transform, pzl, self))
if not pzl.ordered:
pzl = pzl.sort()
return pzl
def is_valid_operation(self, op):
return len(self) == len(op) and all(map(self.is_valid_action, op))
def is_valid_state(self):
return all(map(self.is_valid_elem, self))
def transform(self, pzl):
return pzl.new(map(thiz.transform, self, pzl))
def is_valid_operation(self, op):
return (isinstance(op, TensorOperation) and
len(self) == len(op) and
all(map(thiz.is_valid_operation, self, op)))
def is_valid_state(self):
return all(map(thiz.is_valid_state, self))
def __str__(self):
return "*".join(map(str, self.operations))
