public void add(int value) { res.add(value); } }, maxLength, minMaxValues);
public void testToTableString() { long[][] keysArray = {{}, {-1}, {0, 1, 2, 3}, {10, 20, 30}, {1, 3, 5, 7, 11, 13}}; for (long[] keys : keysArray) { IntArray values = new IntArray(keys.length); for (long key : keys) { values.add((int) (key * key)); } for (T map : createMapsFromLists(new LongArray(keys), values)) { String output; if (map instanceof AbstractWritableLongIntMap) { output = ((AbstractWritableLongIntMap) map).toTableString(); } else if (map instanceof WritableLongIntMapFromLongObjMap) { output = ((WritableLongIntMapFromLongObjMap) map).toTableString(); } else { continue; } int idx = 0, commasCount = 0; for (; idx < output.length() && output.charAt(idx) != '\n'; idx++) { if (output.charAt(idx) == ',') commasCount++; } assertEquals(Math.max(0, keys.length - 1), commasCount); assertFalse(idx == output.length()); idx++; for (; idx < output.length() && output.charAt(idx) != '\n'; idx++) { if (output.charAt(idx) == ',') commasCount--; } assertEquals(0, commasCount); } } }
public void testIndexOf() { int arrayLength = 1000; int maxValue = Integer.MAX_VALUE; IntArray res = new IntArray(arrayLength); int[] intArr = new int[arrayLength]; for (int i = 0; i < arrayLength; i++) { int val = myRand.nextInt(maxValue); res.add(val); intArr[i] = val; } for (int i = 0; i < arrayLength; i++) { int val = res.get(i); assertEquals(res.indexOf(val), IntCollections.indexOf(val, intArr)); } }
public void testRandomCase() { int arrayLength = 1000; int indicesLength = 100; int maxValue = Integer.MAX_VALUE; LongArray list = LongArray.create(); for ( int i = 0; i < arrayLength; i++) { list.add((long) myRand.nextInt(maxValue)); } IntArray arrayIndexes = IntArray.create(); for ( int i = 0; i < indicesLength; i++) { arrayIndexes.add(myRand.nextInt(arrayLength)); } LongArray expected = LongArray.create(); for ( int i = 0; i < indicesLength; i++) { expected.add(list.get(arrayIndexes.get(i))); } LongIndexedIterator res = new LongIndexedIterator(list, arrayIndexes.iterator()); CHECK.order(res, expected.iterator()); } }
/** * 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 IntList getLcsForPermutation(IntList aseq, IntList bseq) { assert aseq.size() == bseq.size() : toBoundedString(aseq) + toBoundedString(bseq); int sz = aseq.size(); IntIntHppcOpenHashMap aseqMap = new IntIntHppcOpenHashMap(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 (IntIterator it : bseq) { ids.add(aseqMap.get(it.value())); } IntList subseq = IntLongestIncreasingSubsequence.getLIS(ids); IntArray res = new IntArray(subseq.size()); for (IntIterator it : subseq) { res.add(aseq.get(it.value())); } return res; }
int curIdx = myRand.nextInt(maxDiff); while (curIdx < source.size()) { indices.add(curIdx); source.insert(curIdx, myRand.nextInt()); curIdx += 1 + myRand.nextInt(maxDiff);
private static void testRevPerm(IntArray perms) { IntArray rev = new IntArray(perms); IntegersUtils.reversePerm(rev); int n = perms.size(); IntArray e = new IntArray(n); for (int i = 0; i < n; ++i) { e.add(perms.get(rev.get(i))); } CHECK.order(IntProgression.arithmetic(0, n).iterator(), e.iterator()); }
int curIdx = myRand.nextInt(maxDiff); while (curIdx < source.size()) { indices.add(curIdx); source.insert(curIdx, myRand.nextInt()); curIdx += 1 + myRand.nextInt(maxDiff);
public void testRemoveKey() { int size = 400, attempts = 10, maxVal = 1000; for (int attempt = 0; attempt < attempts; attempt++) { LongArray keys = generateRandomLongArray(size, SortedStatus.UNORDERED, maxVal); IntArray values = new IntArray(keys.size()); for (int i = 0; i < keys.size(); i++) { long key = keys.get(i); values.add((int) (-key * key)); } map.putAll(keys, values); keys.sortUnique(); for (int i = 0; i < maxVal; i++) { if (keys.binarySearch(i) >= 0) { assertEquals(-i * i, map.remove(i)); } else { assertEquals(0, map.remove(i)); } } } }
public void testRemoveAllAtSorted() { int arSize = 100; int indicesSize = 10; int attempts = 10; for (int attempt = 0; attempt < attempts; attempt++) { array = generateRandomLongArray(arSize, UNORDERED); IntArray indices = generateRandomIntArray(indicesSize, SORTED_UNIQUE, array.size()); if (attempt % 2 == 0) { indices.add(indices.get(indices.size() / 2) + 1); indices.sortUnique(); } LongArray expected = LongArray.copy(array); for (int i = indices.size() - 1; i >= 0; i--) { expected.removeAt(indices.get(i)); } array.removeAllAtSorted(indices.iterator()); CHECK.order(array, expected); } }
/** * 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 testIterators() { // assumed that method createMapsFromLists returns variants with all constructors int attemptsCount = 10; int maxSize = 50; // int maxSize = 1000; for (int attempt = 0; attempt < attemptsCount; attempt++) { LongArray keys = generateRandomLongArray(maxSize, SORTED_UNIQUE); IntArray values = generateRandomIntArray(keys.size(), UNORDERED); for (T map : createMapsFromLists(keys, values)) { LongArray actualKeys = LongCollections.collectIterables(map.size(), map.keysIterator()); IntArray actualValues = IntCollections.collectIterable(map.size(), map.valuesIterator()); CHECK.unordered(actualKeys, keys); CHECK.unordered(actualValues, values); actualKeys.clear(); actualValues.clear(); for (LongIntIterator iter : map) { actualKeys.add(iter.left()); actualValues.add(iter.right()); } CHECK.unordered(actualKeys, keys); CHECK.unordered(actualValues, values); } } }
public void testValuesIterator() { IntArray expected = IntArray.create(1, 1, 2, 2, 3, 3); map.putAll(LongArray.create(0, 2, 4, 6, 8, 10), expected); IntArray actual = IntCollections.collectIterable(expected.size(), map.valuesIterator()); actual.sort(); assertEquals(expected, actual); int size = 20, attempts = 10; for (int attempt = 0; attempt < attempts; attempt++) { map.clear(); LongArray keys = generateRandomLongArray(size, SortedStatus.SORTED_UNIQUE, 100, 200); keys.shuffle(myRand); expected = new IntArray(size); for (int i = 0; i < keys.size(); i++) { long key = keys.get(i); expected.add((int) (key * key)); } map.putAll(keys, expected); actual = new IntArray(map.valuesIterator()); actual.sort(); expected.sort(); CHECK.order(actual.toNativeArray(), expected.toNativeArray()); } }
if (i == attemptsCount - 1) { values.add(myRand.nextLong()); counts.add(0);