def zip(self, pt):
"""Zip skeleton for distributed tree
Precondition
-------------
The distributions of self and pt should be the same
Parameters
----------
pt : :obj:`PTree`
The PTree to zip with the current instance
"""
logger.debug(
'[START] PID[' + str(PID) + '] zip skeleton')
assert self.__distribution == pt.__distribution
content = SList([None] * self.__content.length())
for i in range(len(self.__global_index[self.__start_index: self.__start_index + self.__nb_segs])):
(start, offset) = self.__global_index[self.__start_index: self.__start_index + self.__nb_segs][i]
logger.debug('[START] PID[' + str(PID) + '] zip_local from ' + str(start) + ' to ' + str(start + offset))
content[start:start + offset] = Segment(self.__content[start:start+offset]).\
zip(Segment(pt.__content[start:start+offset]))
logger.debug('[END] PID[' + str(PID) + '] zip_local from ' + str(start) + ' to ' + str(start + offset))
res = PTree.init(self, content)
logger.debug(
'[END] PID[' + str(PID) + '] zip skeleton')
return res
def test_serialization_2_5():
# btree5
bt = Node(
13, Node(3, Leaf(1), Leaf(1)),
Node(9, Node(7, Node(3, Leaf(1), Leaf(1)), Node(3, Leaf(1), Leaf(1))),
Leaf(1)))
m = 5
res = LTree.init_from_bt(bt, m)
seg1 = Segment([TaggedValue(13, "C")])
seg2 = Segment(
[TaggedValue(3, "N"),
TaggedValue(1, "L"),
TaggedValue(1, "L")])
seg3 = Segment(
[TaggedValue(9, "N"),
TaggedValue(7, "C"),
TaggedValue(1, "L")])
seg4 = Segment(
[TaggedValue(3, "N"),
TaggedValue(1, "L"),
TaggedValue(1, "L")])
seg5 = Segment(
[TaggedValue(3, "N"),
TaggedValue(1, "L"),
TaggedValue(1, "L")])
exp = LTree([seg1, seg2, seg3, seg4, seg5])
assert res == exp
def test_has_critical_no():
val1 = TaggedValue(1, "N")
val2 = TaggedValue(2, "L")
seg = Segment([val1, val2])
exp = False
res = seg.has_critical()
assert exp == res
def test_uacc_global_has_critical():
seg = Segment(
[TaggedValue(1, "N"),
TaggedValue(2, "C"),
TaggedValue(2, "L")])
with pytest.raises(AssertionError):
seg.uacc_global(fun.add)
def test_deserialization_2_3():
# btree5
exp = Node(
13, Node(3, Leaf(1), Leaf(1)),
Node(9, Node(7, Node(3, Leaf(1), Leaf(1)), Node(3, Leaf(1), Leaf(1))),
Leaf(1)))
seg1 = Segment([TaggedValue(13, "C")])
seg2 = Segment(
[TaggedValue(3, "N"),
TaggedValue(1, "L"),
TaggedValue(1, "L")])
seg3 = Segment(
[TaggedValue(9, "N"),
TaggedValue(7, "C"),
TaggedValue(1, "L")])
seg4 = Segment(
[TaggedValue(3, "N"),
TaggedValue(1, "L"),
TaggedValue(1, "L")])
seg5 = Segment(
[TaggedValue(3, "N"),
TaggedValue(1, "L"),
TaggedValue(1, "L")])
lt = LTree([seg1, seg2, seg3, seg4, seg5])
res = lt.deserialization()
assert res == exp
def map2(self, f, pt):
"""Map2 skeleton for distributed tree
Precondition
-------------
The distributions of self and pt should be the same
Parameters
----------
pt : :obj:`LTree`
The LTree to zip with the current instance
f : callable
A function to zip values
"""
logger.debug('[START] PID[%s] map2 skeleton', PID)
assert self.__distribution == pt.distribution
content = SList([None] * self.__content.length())
for i in range(
len(self.__global_index[self.__start_index:self.__start_index +
self.__nb_segs])):
(start, offset
) = self.__global_index[self.__start_index:self.__start_index +
self.__nb_segs][i]
logger.debug('[START] PID[%s] map2_local from %s to %s', PID,
start, start + offset)
content[start:start + offset] = Segment(self.__content[start:start + offset]). \
map2(f, Segment(pt.content[start:start + offset]))
logger.debug('[END] PID[%s] map2_local from %s to %s', PID, start,
start + offset)
res = PTree.init(self, content)
logger.debug('[END] PID[%s] map2 skeleton', PID)
return res
def test_reduce_local_leaf():
seg = Segment(
[TaggedValue(1, "N"),
TaggedValue(2, "L"),
TaggedValue(3, "L")])
res = seg.reduce_local(fun.add, fun.idt, fun.add, fun.add)
exp = TaggedValue(6, "L")
assert res == exp
def test_get_right_has_critical():
gt = Segment(
[TaggedValue(2, "N"),
TaggedValue(1, "C"),
TaggedValue(2, "L")])
i = 0
with pytest.raises(AssertionError):
gt.get_right(i)
def test_dacc_global_has_critical():
seg = Segment(
[TaggedValue(1, "N"),
TaggedValue(1, "C"),
TaggedValue(1, "L")])
c = 2
with pytest.raises(AssertionError):
seg.dacc_global(operator.add, c)
def test_zip_not_equal_size_error():
seg1 = Segment(
[TaggedValue(2, "N"),
TaggedValue(1, "L"),
TaggedValue(2, "L")])
seg2 = Segment([TaggedValue(2, "L")])
with pytest.raises(AssertionError):
seg1.zip(seg2)
def test_get_right_is_leaf():
gt = Segment(
[TaggedValue(2, "N"),
TaggedValue(1, "L"),
TaggedValue(2, "L")])
i = 1
with pytest.raises(AssertionError):
gt.get_right(i)
def test_has_critical_yes():
val1 = TaggedValue(1, "N")
val2 = TaggedValue(2, "L")
val3 = TaggedValue(3, "C")
seg = Segment([val1, val2, val3])
exp = True
res = seg.has_critical()
assert exp == res
def test_zipwith_not_equal_size_error():
seg1 = Segment(
[TaggedValue(2, "N"),
TaggedValue(1, "L"),
TaggedValue(2, "L")])
seg2 = Segment([TaggedValue(2, "L")])
with pytest.raises(AssertionError):
seg1.map2(operator.add, seg2)
def test_from_str():
s = "[(11^N); (2^L); (3^C)]"
res = Segment.from_str(s)
exp = Segment(
[TaggedValue(11, "N"),
TaggedValue(2, "L"),
TaggedValue(3, "C")])
assert res == exp
def test_reduce_global_node():
seg = Segment(
[TaggedValue(2, "N"),
TaggedValue(2, "L"),
TaggedValue(2, "L")])
res = seg.reduce_global(fun.add)
exp = 6
assert res == exp
def test_uacc_update_empty():
seg = Segment()
gt = Segment()
lc = 1
rc = 2
res = seg.uacc_update(gt, fun.add, lc, rc)
exp = Segment()
assert res == exp
def test_uacc_illformed():
seg1 = Segment([TaggedValue(13, "C")])
seg3 = Segment(
[TaggedValue(72, "N"),
TaggedValue(92, "L"),
TaggedValue(42, "L")])
lt = LTree([seg1, seg3])
with pytest.raises(IllFormedError):
lt.uacc(fun.add, fun.idt, fun.add, fun.add, fun.add)
def test_get_right_direct():
gt = Segment(
[TaggedValue(2, "N"),
TaggedValue(1, "L"),
TaggedValue(2, "L")])
i = 0
res = gt.get_right(i)
exp = TaggedValue(2, "L")
assert res == exp
def test_uacc_local_prefix_1():
seg = Segment(
[TaggedValue(1, "N"),
TaggedValue(2, "C"),
TaggedValue((0, 1), "L")])
res = seg.uacc_local(k, phi, psi_l, psi_r)
exp = (TaggedValue((0, 1, 1, 4),
"N"), Segment([None, None,
TaggedValue((0, 1), "L")]))
assert res == exp
def test_map2():
seg11 = Segment([TaggedValue(1, "C")])
seg21 = Segment(
[TaggedValue(1, "N"),
TaggedValue(1, "L"),
TaggedValue(1, "L")])
seg31 = Segment(
[TaggedValue(1, "N"),
TaggedValue(1, "L"),
TaggedValue(1, "L")])
lt1 = LTree([seg11, seg21, seg31])
seg12 = Segment([TaggedValue(2, "C")])
seg22 = Segment(
[TaggedValue(2, "N"),
TaggedValue(2, "L"),
TaggedValue(2, "L")])
seg32 = Segment(
[TaggedValue(2, "N"),
TaggedValue(2, "L"),
TaggedValue(2, "L")])
lt2 = LTree([seg12, seg22, seg32])
res = lt1.map2(operator.add, lt2)
seg1_exp = Segment([TaggedValue(3, "C")])
seg2_exp = Segment(
[TaggedValue(3, "N"),
TaggedValue(3, "L"),
TaggedValue(3, "L")])
seg3_exp = Segment(
[TaggedValue(3, "N"),
TaggedValue(3, "L"),
TaggedValue(3, "L")])
exp = LTree([seg1_exp, seg2_exp, seg3_exp])
assert res == exp
def test_zip():
seg11 = Segment([TaggedValue(1, "C")])
seg21 = Segment(
[TaggedValue(1, "N"),
TaggedValue(1, "L"),
TaggedValue(1, "L")])
seg31 = Segment(
[TaggedValue(1, "N"),
TaggedValue(1, "L"),
TaggedValue(1, "L")])
lt1 = LTree([seg11, seg21, seg31])
seg12 = Segment([TaggedValue(2, "C")])
seg22 = Segment(
[TaggedValue(2, "N"),
TaggedValue(2, "L"),
TaggedValue(2, "L")])
seg32 = Segment(
[TaggedValue(2, "N"),
TaggedValue(2, "L"),
TaggedValue(2, "L")])
lt2 = LTree([seg12, seg22, seg32])
res = lt1.zip(lt2)
seg1_exp = Segment([TaggedValue((1, 2), "C")])
seg2_exp = Segment([
TaggedValue((1, 2), "N"),
TaggedValue((1, 2), "L"),
TaggedValue((1, 2), "L")
])
seg3_exp = Segment([
TaggedValue((1, 2), "N"),
TaggedValue((1, 2), "L"),
TaggedValue((1, 2), "L")
])
exp = LTree([seg1_exp, seg2_exp, seg3_exp])
assert res == exp
def test_map_local():
seg = Segment(
[TaggedValue(1, "N"),
TaggedValue(2, "L"),
TaggedValue(3, "C")])
res = seg.map_local(lambda x: x + 1, lambda x: x - 1)
exp = Segment(
[TaggedValue(0, "N"),
TaggedValue(3, "L"),
TaggedValue(2, "C")])
assert exp == res
def test_zipwith_not_same_tag_error():
seg1 = Segment(
[TaggedValue(2, "N"),
TaggedValue(1, "L"),
TaggedValue(2, "L")])
seg2 = Segment(
[TaggedValue(2, "N"),
TaggedValue(1, "C"),
TaggedValue(2, "L")])
with pytest.raises(NotSameTagError):
seg1.map2(operator.add, seg2)
def test_zip_not_same_tag_error():
seg1 = Segment(
[TaggedValue(2, "N"),
TaggedValue(1, "L"),
TaggedValue(2, "L")])
seg2 = Segment(
[TaggedValue(2, "N"),
TaggedValue(1, "C"),
TaggedValue(2, "L")])
with pytest.raises(NotSameTagError):
seg1.zip(seg2)
def test_dacc_path_gt_node():
seg = Segment([
TaggedValue(1, "N"),
TaggedValue(2, "L"),
TaggedValue(1, "N"),
TaggedValue(2, "L"),
TaggedValue(3, "C")
])
res = seg.dacc_path(fun.idt, fun.idt, operator.add)
exp = TaggedValue((5, 5), "N")
assert res == exp
def test_uacc_global_prefix():
gt = Segment([
TaggedValue((0, 1, 1, 4), "N"),
TaggedValue((1, 3), "L"),
TaggedValue((1, 3), "L")
])
res = gt.uacc_global(psi_n)
exp = Segment([
TaggedValue((8, 11), "N"),
TaggedValue((1, 3), "L"),
TaggedValue((1, 3), "L")
])
assert res == exp
def test_uacc_update_not_same_size():
seg = Segment([
TaggedValue(1, "N"),
TaggedValue(2, "L"),
TaggedValue(1, "N"),
TaggedValue(2, "L"),
TaggedValue(3, "L")
])
gt = Segment()
lc = 1
rc = 2
with pytest.raises(AssertionError):
seg.uacc_update(gt, fun.add, lc, rc)
def test_uacc_update_illformed_critical():
seg = Segment(
[TaggedValue(1, "N"),
TaggedValue(2, "C"),
TaggedValue(1, "N")])
gt = Segment(
[TaggedValue(1, "N"),
TaggedValue(2, "L"),
TaggedValue(1, "L")])
lc = 1
rc = 2
with pytest.raises(IllFormedError):
seg.uacc_update(gt, fun.add, lc, rc)
def test_reduce():
seg1 = Segment([TaggedValue(13, "C")])
seg2 = Segment(
[TaggedValue(31, "N"),
TaggedValue(47, "L"),
TaggedValue(32, "L")])
seg3 = Segment(
[TaggedValue(72, "N"),
TaggedValue(92, "L"),
TaggedValue(42, "L")])
lt = LTree([seg1, seg2, seg3])
res = lt.reduce(fun.add, fun.idt, fun.add, fun.add, fun.add)
exp = 13 + 31 + 47 + 32 + 72 + 92 + 42
assert res == exp
def test_uacc_local_prefix_3():
seg = Segment([
TaggedValue(5, "N"),
TaggedValue((0, 1), "L"),
TaggedValue((0, 1), "L")
])
res = seg.uacc_local(k, phi, psi_l, psi_r)
exp = (TaggedValue((1, 3), "L"),
Segment([
TaggedValue((1, 3), "N"),
TaggedValue((0, 1), "L"),
TaggedValue((0, 1), "L")
]))
assert res == exp