def test_ordered_inner_map_both_unique(self):
a_ids = np.asarray([0, 1, 2, 3, 5, 6, 8], dtype=np.int64)
b_ids = np.asarray([1, 2, 3, 5, 6, 7, 8], dtype=np.int64)
result_size = ops.ordered_inner_map_result_size(a_ids, b_ids)
a_map = np.zeros(result_size, dtype=np.int64)
b_map = np.zeros(result_size, dtype=np.int64)
ops.ordered_inner_map_both_unique(a_ids, b_ids, a_map, b_map)
expected_a = np.array([1, 2, 3, 4, 5, 6], dtype=np.int64)
expected_b = np.array([0, 1, 2, 3, 4, 6], dtype=np.int64)
self.assertTrue(np.array_equal(a_map, expected_a))
self.assertTrue(np.array_equal(b_map, expected_b))
a_map = np.zeros(result_size, dtype=np.int64)
b_map = np.zeros(result_size, dtype=np.int64)
ops.ordered_inner_map_left_unique(a_ids, b_ids, a_map, b_map)
expected_a = np.array([1, 2, 3, 4, 5, 6], dtype=np.int64)
expected_b = np.array([0, 1, 2, 3, 4, 6], dtype=np.int64)
self.assertTrue(np.array_equal(a_map, expected_a))
self.assertTrue(np.array_equal(b_map, expected_b))
a_map = np.zeros(result_size, dtype=np.int64)
b_map = np.zeros(result_size, dtype=np.int64)
ops.ordered_inner_map(a_ids, b_ids, a_map, b_map)
expected_a = np.array([1, 2, 3, 4, 5, 6], dtype=np.int64)
expected_b = np.array([0, 1, 2, 3, 4, 6], dtype=np.int64)
self.assertTrue(np.array_equal(a_map, expected_a))
self.assertTrue(np.array_equal(b_map, expected_b))
def ordered_merge_inner(self,
left_on,
right_on,
left_field_sources=tuple(),
left_field_sinks=None,
right_field_sources=tuple(),
right_field_sinks=None,
left_unique=False,
right_unique=False):
if left_field_sinks is not None:
if len(left_field_sources) != len(left_field_sinks):
msg = (
"{} and {} should be of the same length but are length {} and {} "
"respectively")
raise ValueError(
msg.format(len(left_field_sources), len(left_field_sinks)))
val.all_same_basic_type('left_field_sources', left_field_sources)
if left_field_sinks and len(left_field_sinks) > 0:
val.all_same_basic_type('left_field_sinks', left_field_sinks)
if right_field_sinks is not None:
if len(right_field_sources) != len(right_field_sinks):
msg = (
"{} and {} should be of the same length but are length {} and {} "
"respectively")
raise ValueError(
msg.format(len(right_field_sources),
len(right_field_sinks)))
val.all_same_basic_type('right_field_sources', right_field_sources)
if right_field_sinks and len(right_field_sinks) > 0:
val.all_same_basic_type('right_field_sinks', right_field_sinks)
left_data = val.array_from_parameter(self, 'left_on', left_on)
right_data = val.array_from_parameter(self, 'right_on', right_on)
result = None
inner_length = ops.ordered_inner_map_result_size(left_data, right_data)
left_to_inner = np.zeros(inner_length, dtype=np.int64)
right_to_inner = np.zeros(inner_length, dtype=np.int64)
if left_unique is False:
if right_unique is False:
ops.ordered_inner_map(left_data, right_data, left_to_inner,
right_to_inner)
else:
ops.ordered_inner_map_left_unique(right_data, left_data,
right_to_inner,
left_to_inner)
else:
if right_unique is False:
ops.ordered_inner_map_left_unique(left_data, right_data,
left_to_inner,
right_to_inner)
else:
ops.ordered_inner_map_both_unique(left_data, right_data,
left_to_inner,
right_to_inner)
rtn_left_sinks = self._map_fields(left_to_inner, left_field_sources,
left_field_sinks)
rtn_right_sinks = self._map_fields(right_to_inner, right_field_sources,
right_field_sinks)
if rtn_left_sinks:
if rtn_right_sinks:
return rtn_left_sinks, rtn_right_sinks
else:
return rtn_left_sinks
else:
return rtn_right_sinks