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)