public static <T> IntObjHppcOpenHashMap<T> createFrom(IntIterable keys, Iterable<T> values) { int keysSize = (keys instanceof IntSizedIterable) ? ((IntSizedIterable) keys).size() : 0; int valuesSize = (values instanceof Collection) ? ((Collection) keys).size() : 0; float loadFactor = IntIntOpenHashMap.DEFAULT_LOAD_FACTOR; int initialCapacity = (int)(Math.max(keysSize, valuesSize) / loadFactor) + 1; IntObjHppcOpenHashMap map = new IntObjHppcOpenHashMap(initialCapacity); IntIterator keysIt = keys.iterator(); Iterator valuesIt = values.iterator(); map.putAll(IntObjIterators.pair(keysIt, valuesIt)); if (keysIt.hasNext() || valuesIt.hasNext()) { throw new IllegalArgumentException("keys.size() != values.size()"); } return map; }
public void testIndexSimple() { LongArray source = LongArray.create(1, 3, 4, 7, 8, 9); LongListInsertingDecorator tst = new LongListInsertingDecorator(source, new IntLongListMap()); IntArray toInsert = IntArray.create(0, 2, 5, 6, 10); for (IntIterator it : toInsert) { tst.insert(it.value(), it.value()); } // [0*, 1, 2*, 3, 4, 5*, 6*, 7, 8, 9, 10*] LongListIterator it = tst.iterator(); while (it.hasNext()) { it.next(); assertEquals(it.index(), it.value()); } checkCollection(tst, LongProgression.Arithmetic.nativeArray(0, 11, 1)); }
/** * 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; }
/** * 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 static IntIntHppcOpenHashMap createFrom(IntIterable keys, IntIterable values) { int keysSize = IntCollections.sizeOfIterable(keys, 0); int valuesSize = IntCollections.sizeOfIterable(values, 0); if (keysSize != valuesSize) { throw new IllegalArgumentException("keys.size() != values.size()"); } else { keysSize = Math.max(keysSize, valuesSize); } float loadFactor = IntIntOpenHashMap.DEFAULT_LOAD_FACTOR; int initialCapacity = (int)(keysSize / loadFactor) + 1; IntIntHppcOpenHashMap map = new IntIntHppcOpenHashMap(initialCapacity); IntIterator keysIt = keys.iterator(); IntIterator valuesIt = values.iterator(); map.putAll(IntIntIterators.pair(keysIt, valuesIt)); if (keysIt.hasNext() || valuesIt.hasNext()) { throw new IllegalArgumentException("keys.size() != values.size()"); } return map; }
public static void test(Random random, BinarySearcher bs) { check(bs, LongArray.create(0, 2, 5, 10)); check(bs, LongArray.create(0, 5, 10, 11, 12, 14, 20, 25, 25)); check(bs, LongArray.create(0, 5, 10, 11, 12, 12, 12, 14, 20, 25)); check(bs, LongArray.create(0, 0, 10, 20, 30)); check(bs, LongArray.create(10)); check(bs, LongArray.create(10, 20)); check(bs, LongArray.create(10, 10)); check(bs, LongArray.create()); int arrLength = 100; for (IntIterator it : IntIterators.range(50, 400, 50)) { LongArray array = IntegersFixture.generateRandomLongArray(random, arrLength, SORTED, it.value()); check(bs, array); } }
public static IntLongHppcOpenHashMap createFrom(IntIterable keys, LongIterable values) { int keysSize = IntCollections.sizeOfIterable(keys, 0); int valuesSize = LongCollections.sizeOfIterable(values, 0); if (keysSize != valuesSize) { throw new IllegalArgumentException("keys.size() != values.size()"); } else { keysSize = Math.max(keysSize, valuesSize); } float loadFactor = IntLongOpenHashMap.DEFAULT_LOAD_FACTOR; int initialCapacity = (int)(keysSize / loadFactor) + 1; IntLongHppcOpenHashMap map = new IntLongHppcOpenHashMap(initialCapacity); IntIterator keysIt = keys.iterator(); LongIterator valuesIt = values.iterator(); map.putAll(IntLongIterators.pair(keysIt, valuesIt)); if (keysIt.hasNext() || valuesIt.hasNext()) { throw new IllegalArgumentException("keys.size() != values.size()"); } return map; }
public static LongIntHppcOpenHashMap createFrom(LongIterable keys, IntIterable values) { int keysSize = LongCollections.sizeOfIterable(keys, 0); int valuesSize = IntCollections.sizeOfIterable(values, 0); if (keysSize != valuesSize) { throw new IllegalArgumentException("keys.size() != values.size()"); } else { keysSize = Math.max(keysSize, valuesSize); } float loadFactor = LongIntOpenHashMap.DEFAULT_LOAD_FACTOR; int initialCapacity = (int)(keysSize / loadFactor) + 1; LongIntHppcOpenHashMap map = new LongIntHppcOpenHashMap(initialCapacity); LongIterator keysIt = keys.iterator(); IntIterator valuesIt = values.iterator(); map.putAll(LongIntIterators.pair(keysIt, valuesIt)); if (keysIt.hasNext() || valuesIt.hasNext()) { throw new IllegalArgumentException("keys.size() != values.size()"); } return map; }