def testIn1d(self):
pdaOne = ak.array([-1, 0, 1, 3])
pdaTwo = ak.array([-1, 2, 2, 3])
self.assertTrue(
(ak.in1d(pdaOne, pdaTwo) == ak.array([True, False, False,
True])).all())
vals = [i % 3 for i in range(10)]
valsTwo = [i % 2 for i in range(10)]
stringsOne = ak.array(['String {}'.format(i) for i in vals])
stringsTwo = ak.array(['String {}'.format(i) for i in valsTwo])
answer = ak.array([x < 2 for x in vals])
self.assertTrue((answer == ak.in1d(stringsOne, stringsTwo)).all())
def run_test_in1d(strings, cat, base_words):
more_choices = ak.randint(0, UNIQUE, 100)
akwords = base_words[more_choices]
more_words = akwords.to_ndarray()
matches = ak.in1d(strings, akwords)
catmatches = ak.in1d(cat, akwords)
assert((matches == catmatches).all())
# Every word in matches should be in the target set
for word in strings[matches].to_ndarray():
assert(word in more_words)
# Exhaustively find all matches to make sure we didn't miss any
inds = ak.zeros(strings.size, dtype=ak.bool)
for word in more_words:
inds |= (strings == word)
assert((inds == matches).all())
def testIn1d(self):
vals = [i % 3 for i in range(10)]
valsTwo = [i % 2 for i in range(10)]
stringsOne = ak.array(['String {}'.format(i) for i in vals])
stringsTwo = ak.array(['String {}'.format(i) for i in valsTwo])
catOne = ak.Categorical(stringsOne)
catTwo = ak.Categorical(stringsTwo)
answer = ak.array([x < 2 for x in vals])
self.assertTrue((answer == ak.in1d(catOne,catTwo)).all())
self.assertTrue((answer == ak.in1d(catOne,stringsTwo)).all())
with self.assertRaises(TypeError) as cm:
ak.in1d(catOne, ak.randint(0,5,5))
self.assertEqual(('type of argument "test" must be one of (Strings, Categorical); got ' +
'arkouda.pdarrayclass.pdarray instead'), cm.exception.args[0])
def test_unused_categories_logic(self):
"""
Test that Categoricals built from_codes and from slices that have unused categories behave correctly
"""
s = ak.array([str(i) for i in range(10)])
s12 = s[1:3]
cat = ak.Categorical(s)
cat12 = cat[1:3]
self.assertListEqual(
ak.in1d(s, s12).to_ndarray().tolist(),
ak.in1d(cat, cat12).to_ndarray().tolist())
self.assertSetEqual(set(ak.unique(s12).to_ndarray().tolist()),
set(ak.unique(cat12).to_ndarray().tolist()))
cat_from_codes = ak.Categorical.from_codes(ak.array([1, 2]), s)
self.assertListEqual(
ak.in1d(s, s12).to_ndarray().tolist(),
ak.in1d(cat, cat_from_codes).to_ndarray().tolist())
self.assertSetEqual(
set(ak.unique(s12).to_ndarray().tolist()),
set(ak.unique(cat_from_codes).to_ndarray().tolist()))
def compare_results(akres, sortedres) -> int:
'''
Compares the numpy and arkouda arrays via the numpy.allclose method with the
default relative and absolute tolerances, returning 0 if the arrays are similar
element-wise within the tolerances, 1 if they are dissimilar.element
:return: 0 (identical) or 1 (dissimilar)
:rtype: int
'''
akres = akres.to_ndarray()
if not np.array_equal(akres, sortedres):
akres = ak.array(akres)
sortedres = ak.array(sortedres)
innp = sortedres[ak.in1d(ak.array(sortedres), ak.array(akres),
True)] # values in np array, but not ak array
inak = akres[ak.in1d(ak.array(akres), ak.array(sortedres),
True)] # values in ak array, not not np array
print(
f"(values in np but not ak: {innp}) (values in ak but not np: {inak})"
)
return 1
return 0
# comparison
run_comparison_test(strings, test_strings, cat)
print("comparison passed")
# pdarray bool index
test_pdarray_index(strings, test_strings, cat)
print("pdarray bool index passed")
# in1d and iter
# more_words = np.random.choice(base_words, 100)
# akwords = ak.array(more_words)
more_choices = ak.randint(0, UNIQUE, 100)
akwords = base_words[more_choices]
more_words = akwords.to_ndarray()
matches = ak.in1d(strings, akwords)
catmatches = ak.in1d(cat, akwords)
assert ((matches == catmatches).all())
# Every word in matches should be in the target set
for word in strings[matches]:
assert (word in more_words)
# Exhaustively find all matches to make sure we didn't miss any
inds = ak.zeros(strings.size, dtype=ak.bool)
for word in more_words:
inds |= (strings == word)
assert ((inds == matches).all())
print("in1d and iter passed")
# argsort
test_argsort(strings, test_strings, cat)
def testOneDimensionalSetXor(self):
set_xor = ak.setxor1d(self.a, self.b)
set_intersection = ak.intersect1d(self.a, self.b)
# elements NOT in the intersection of a and b
self.assertTrue(ak.all(ak.in1d(set_xor, set_intersection,
invert=True)))
def testOneDimensionalSetDifference(self):
set_difference = ak.setdiff1d(self.a, self.b)
# elements in a and not in b
self.assertTrue((ak.in1d(set_difference,self.a).all() & \
ak.in1d(set_difference,self.b,invert=True).all()))
def testOneDimensionalSetIntersection(self):
set_intersection = ak.intersect1d(self.a, self.b)
# elements in a and elements in b (elements in both a and b)
self.assertTrue(ak.all(ak.in1d(set_intersection,self.a) & \
ak.in1d(set_intersection,self.b)))
def testOneDimensionalSetUnion(self):
set_union = ak.union1d(self.a, self.b)
# elements in a or elements in b (or in both a and b)
self.assertTrue(ak.all(ak.in1d(set_union,self.a) \
| ak.in1d(set_union,self.b)))
type=int,
default=10**6,
help='Problem size: length of array to argsort')
args = parser.parse_args()
ak.verbose = False
ak.connect(args.hostname, args.port)
print("size = ", args.size)
SIZE = args.size
a = ak.randint(0, 2 * SIZE, SIZE)
b = ak.randint(0, 2 * SIZE, SIZE)
set_union = ak.union1d(a, b)
print("union1d = ", set_union.size, set_union)
# elements in a or elements in b (or in both a and b)
passed = ak.all(ak.in1d(set_union, a) | ak.in1d(set_union, b))
print("union1d passed test: ", passed)
set_intersection = ak.intersect1d(a, b)
print("intersect1d = ", set_intersection.size, set_intersection)
# elements in a and elements in b (elements in both a and b)
passed = ak.all(
ak.in1d(set_intersection, a) & ak.in1d(set_intersection, b))
print("intersect1d passed test: ", passed)
set_difference = ak.setdiff1d(a, b)
print("setdiff1d = ", set_difference.size, set_difference)
# elements in a and not in b
passed = ak.all(
ak.in1d(set_difference, a) & ak.in1d(set_difference, b, invert=True))
print("setdiff1d passed test: ", passed)
