public void testHasMethods() { int MIN = Integer.MIN_VALUE, MAX = Integer.MAX_VALUE; LongArray someValues = LongArray.create(MIN, MIN + 1, 0, 1, 3, 5, MAX - 1, MAX); for (LongArray first : LongCollections.allSubLists(someValues)) { for (LongArray second : LongCollections.allSubLists(someValues)) { IntegersDebug.println(LongCollections.toBoundedString(first) + " " + LongCollections.toBoundedString(second)); assertEquals(new LongUnionIterator(first, second).hasNext(), hasUnion(first, second)); assertEquals(new LongIntersectionIterator(first, second).hasNext(), hasIntersection(first, second)); assertEquals(new LongMinusIterator(first.iterator(), second.iterator()).hasNext(), hasComplement(first, second)); } } }
public void testSort() { long[][] ars = {{}, {0,1,2}, {2,4,6}, {0,1}, {5,7,9}, {-1, 1, 2}, {0}, {10}, {0,1,2,3}}; LongArray[] arrays = new LongArray[ars.length + 1]; for (int i = 0; i < ars.length; i++) { arrays[i] = new LongArray(ars[i]); } arrays[ars.length] = null; Arrays.sort(arrays, comparator); StringBuilder sb = new StringBuilder(); for (LongArray array: arrays) { LongCollections.append(sb, array); } assertEquals("" + "null" + "()" + "(-1, 1, 2)" + "(0)(0, 1)" + "(0, 1, 2)" + "(0, 1, 2, 3)" + "(2, 4, 6)" + "(5, 7, 9)" + "(10)", sb.toString()); }
public void testArrayCopy() { int arrayLength = 1000; int maxValue = Integer.MAX_VALUE; long[] res = new long[arrayLength]; long[] expected = new long[arrayLength]; for (int i = 0; i < arrayLength; i++) { res[i] = myRand.nextInt(maxValue); expected[i] = res[i]; } long[] copy = LongCollections.arrayCopy(res); CHECK.order(expected, copy); }
public void checkAllSubLists(LongList list, ArrayList<Long>[] lists, int size) { int i = 0; for (LongArray array : allSubLists(list)) { CHECK.order(LongCollections.asLongList(lists[i++]), array); } assertEquals(size, i); }
public void testContains2() { int arSize = 45, maxVal = Integer.MAX_VALUE, attempts = 10; for (int attempt = 0; attempt < attempts; attempt++) { LongArray arr = generateRandomLongArray(arSize, SORTED_UNIQUE, maxVal); LongArray arr2 = LongCollections.collectLists(arr, map(LongFunctions.INC, arr), map(LongFunctions.DEC, arr)); arr2.sortUnique(); for (WritableLongSet curSet : createSets(arr)) { for (int i = 0; i < arr2.size(); i++) { long value = arr2.get(i); assertEquals(arr.binarySearch(value) >= 0, curSet.contains(value)); } } } }
private void testSetOperations() { LongArray someValues = LongArray.create(MIN, MIN + 1, 0, 1, 3, 5, MAX - 1, MAX); for (LongArray first : LongCollections.allSubLists(someValues)) { for (LongArray second : LongCollections.allSubLists(someValues)) { IntegersDebug.println(LongCollections.toBoundedString(first) + " " + LongCollections.toBoundedString(second)); checkNewSetCreator(first, second); LongArray complement = collectIterables(new LongMinusIterator(generateRandomLongArray(myRand, 1000, SortedStatus.SORTED_UNIQUE), first)); if (getCurrentStatus(0) == UNORDERED) { first.shuffle(myRand);
public void testContainsAny() { for (T set : createSets(LongList.EMPTY)) { assertFalse(set.containsAny(set)); assertFalse(set.containsAny(LongSet.EMPTY)); assertFalse(set.containsAny(LongList.EMPTY)); assertFalse(set.containsAny(LongIterator.EMPTY)); } LongArray check = collectIterables(create(Long.MIN_VALUE, Long.MAX_VALUE, 239), LongProgression.range(10)); check.sortUnique(); LongArray list = new LongArray(LongProgression.range(0, 10, 2)); for (T set : createSets(list)) { for (LongArray array : LongCollections.allSubLists(check)) { assertEquals(hasIntersection(list, check), set.containsAny(check)); } } }
public void testContains() { int arSize = 45, maxVal = Integer.MAX_VALUE, attempts = 10; for (int attempt = 0; attempt < attempts; attempt++) { LongArray arr = generateRandomLongArray(arSize, SORTED_UNIQUE, maxVal); LongArray arr2 = LongCollections.collectLists(arr, map(LongFunctions.INC, arr), map(LongFunctions.DEC, arr)); arr2.sortUnique(); for (LongSet curSet : createSets(arr)) { for (int i = 0; i < arr2.size(); i++) { long value = arr2.get(i); assertEquals(arr.binarySearch(value) >= 0, curSet.contains(value)); } assertTrue(curSet.containsAll(arr)); assertTrue(curSet.containsAll(curSet)); assertTrue(curSet.containsAll(curSet.iterator())); assertTrue(curSet.containsAll(LongList.EMPTY)); assertFalse(curSet.containsAll(concatLists(arr, new LongList.Single(arr.getLast(0) + 1)))); assertEquals(arr.size(), curSet.size()); } } }
/** * contract: aseq shouldn't contain duplicates and bseq should be permutation of aseq. * @param aseq list without duplicates * @param bseq list without duplicates * @return longest common subsequence for {@code aseq} and {@code bseq} */ public static LongList getLcsForPermutation(LongList aseq, LongList bseq) { assert aseq.size() == bseq.size() : toBoundedString(aseq) + toBoundedString(bseq); int sz = aseq.size(); LongIntHppcOpenHashMap aseqMap = new LongIntHppcOpenHashMap(sz); for (int i = 0; i < sz; i++) { assert !aseqMap.containsKey(aseq.get(i)) : "duplicates aren't allowed in aseq: " + aseq.get(i); // check no duplicates in aseq aseqMap.put(aseq.get(i), i); } assert aseqMap.size() == bseq.size() && aseqMap.containsKeys(bseq) : "bseq should be permutation of aseq: " + toBoundedString(aseqMap.keySet()) + " " + toBoundedString(bseq); IntArray ids = new IntArray(); for (LongIterator it : bseq) { ids.add(aseqMap.get(it.value())); } IntList subseq = IntLongestIncreasingSubsequence.getLIS(ids); LongArray res = new LongArray(subseq.size()); for (IntIterator it : subseq) { res.add(aseq.get(it.value())); } return res; }
public void testSimple() { int[][] leftVariants = {{}, {0, 1, 2}, {10, 20, 30}, {0, 2, 4, 6}, {Integer.MIN_VALUE, Integer.MAX_VALUE, 1, 2, 0}}; for (int[] left : leftVariants) { for (int[] right0 : leftVariants) { IntList leftList = new IntArray(left); LongList rightList = LongCollections.asLongList(new IntArray(right0)); IntList leftSingle = new IntList.Single(Integer.MIN_VALUE); LongList rightSingle = new LongList.Single(Long.MIN_VALUE); checkPairIterator(left, right0, leftList, rightList); if (leftList.size() == rightList.size()) { checkPairIterator(left, right0, IntCollections.concatLists(leftList, leftSingle), rightList); checkPairIterator(left, right0, leftList, LongCollections.concatLists(rightList, rightSingle)); } } } }
public void checkCollect(LongList ... lists) { LongArray expected = new LongArray(); for (LongList array : lists) { expected.addAll(array); } CHECK.order(expected, collectLists(lists)); int attemptsCount = 5; for (int attempt = 0; attempt < attemptsCount; attempt++) { LongIterable[] iterables = new LongIterable[lists.length]; for (int i = 0; i < lists.length; i++) { switch (myRand.nextInt(3)) { case 0: iterables[i] = lists[i]; break; case 1: iterables[i] = lists[i].iterator(); break; case 2: int size2 = lists[i].size() / 2; iterables[i] = new LongConcatIterator(lists[i].subList(0, size2), lists[i].subList(size2, lists[i].size())); break; default: assert false; } } CHECK.order(expected, collectIterables(iterables)); for (int i = 0; i < iterables.length; i++) { if (iterables[i] instanceof LongIterator) { iterables[i] = lists[i].iterator(); } } CHECK.order(expected, collectIterables(expected.size(), iterables)); } }
public void testSimpleResize() { long[] values0 = {-1, 0, 10, -10, 20, 30}; LongArray values = new LongArray(values0); LongArray toAdd = LongArray.create(0, -4, -10, 20); LongList expected = LongCollections.concatLists(values, toAdd); for (WritableLongList list : createWritableLongLists(values0)) { CHECK.order(values, list); list.addAll(toAdd); CHECK.order(expected, list); } LongList valuesList = LongProgression.range(1024); values0 = valuesList.toNativeArray(); long[] expected0 = LongCollections.collectLists(valuesList, new LongList.Single(1025)).extractHostArray(); for (WritableLongList list : createWritableLongLists(values0)) { list.add(1025); CHECK.order(list, expected0); } }
public void testAsLongList() { List<Long> arr = new ArrayList<Long>(); for (int i = 0; i < 10; i += 2) { arr.add(Long.valueOf(i)); } LongList res = asLongList(arr); CHECK.order(LongArray.create(0,2,4,6,8), res); arr.clear(); res = asLongList(arr); assertEquals(res, LongList.EMPTY); }
public void testRandom() { LongArray[] arrays = new LongArray[5]; for (int i = 0; i < 20; i++) { for (int j = 0; j < arrays.length; j++) { arrays[j] = generateRandomLongArray(30, IntegersFixture.SortedStatus.UNORDERED); } CHECK.order(collectIterables(300, arrays).iterator(), LongIterators.concat(arrays)); } } }
public void order(LongIterator actual, long ... expected) { order(LongCollections.collectIterable(expected.length, actual).toNativeArray(), expected); }
public void testGetBounds() { if (!isSortedSet()) return; LongArray values = create(MIN, MIN + 1, 0, 1, MAX - 1, MAX); for (LongArray array : LongCollections.allSubLists(values)) { checkBounds(array); } }
public int binSearch(long value) { return LongCollections.binarySearch(value, arr); } });
@Override public LongIterator get(LongArray... arrays) { return LongCollections.complementSorted(arrays[0], arrays[1]).iterator(); } }, new SetOperationsChecker.MinusGetter(), true, SORTED_UNIQUE, SORTED);
public void testPut() { int size = 100, attempts = 10, maxVal = 1000; for (int attempt = 0; attempt < attempts; attempt++) { map.clear(); LongArray keys = generateRandomLongArray(size, SortedStatus.SORTED_UNIQUE, maxVal); LongArray shuffledKeys = LongCollections.collectLists(keys, keys); shuffledKeys.shuffle(myRand); for (int i = 0; i < shuffledKeys.size(); i++) { long key = shuffledKeys.get(i); long prevValue = map.get(key); assertEquals(prevValue, map.put(key, (int) (-key * key))); } } }
public void testContains3() { int arSize = 45, maxVal = Integer.MAX_VALUE, attempts = 10; for (int attempt = 0; attempt < attempts; attempt++) { LongArray arr = generateRandomLongArray(arSize, SORTED_UNIQUE, maxVal); LongArray arr2 = LongCollections.collectLists(arr, map(LongFunctions.INC, arr), map(LongFunctions.DEC, arr)); arr2.sortUnique(); for (WritableLongSet curSet : createSets(arr)) { for (int i = 0; i < arr2.size(); i++) { long value = arr2.get(i); boolean contains = arr.binarySearch(value) >= 0; assertEquals(contains, curSet.contains(value)); assertEquals(contains, curSet.exclude(value)); assertEquals(false, curSet.contains(value)); } } } }