@Parameterized.Parameters(name = "{index}: compression={0}, byteOrder={1}") public static Iterable<Object[]> compressionStrategies() { final Iterable<CompressedObjectStrategy.CompressionStrategy> compressionStrategies = Iterables.transform( CompressionStrategyTest.compressionStrategies(), new Function<Object[], CompressedObjectStrategy.CompressionStrategy>() { @Override public CompressedObjectStrategy.CompressionStrategy apply(Object[] input) { return (CompressedObjectStrategy.CompressionStrategy) input[0]; } }); Set<List<Object>> combinations = Sets.cartesianProduct( Sets.newHashSet(compressionStrategies), Sets.newHashSet(ByteOrder.BIG_ENDIAN, ByteOrder.LITTLE_ENDIAN)); return Iterables.transform( combinations, new Function<List, Object[]>() { @Override public Object[] apply(List input) { return new Object[] {input.get(0), input.get(1)}; } }); }
private static Set<List<Comparable<?>>> getPartitionKeysSet( CassandraTable table, TupleDomain<ColumnHandle> tupleDomain) { ImmutableList.Builder<Set<Comparable<?>>> partitionColumnValues = ImmutableList.builder(); for (CassandraColumnHandle columnHandle : table.getPartitionKeyColumns()) { Domain domain = tupleDomain.getDomains().get(columnHandle); // if there is no constraint on a partition key, return an empty set if (domain == null) { return ImmutableSet.of(); } // todo does cassandra allow null partition keys? if (domain.isNullAllowed()) { return ImmutableSet.of(); } ImmutableSet.Builder<Comparable<?>> columnValues = ImmutableSet.builder(); for (Range range : domain.getRanges()) { // if the range is not a single value, we can not perform partition pruning if (!range.isSingleValue()) { return ImmutableSet.of(); } Comparable<?> value = range.getSingleValue(); CassandraType valueType = columnHandle.getCassandraType(); columnValues.add(valueType.getValueForPartitionKey(value)); } partitionColumnValues.add(columnValues.build()); } return Sets.cartesianProduct(partitionColumnValues.build()); }
/** * Vraci seznam vsech kombinaci pro zadanou strategy * * @param strategyName jmeno strategie * @return {key=cci, value=1;key=ema, value=13} {key=cci, value=2;key=ema, value=13} {key=cci, * value=1;key=ema, value=14} atd... */ public static List<Map<String, Integer>> getParametersCombination(String strategyName) { Map<String, Integer> map; List<Map<String, Integer>> list = new ArrayList<Map<String, Integer>>(); // nactu z konfigu seznam vsech klicu List<String> keys = PropertyHelper.getAllOptimizationParamsForStrategy(strategyName); // naplnim si mapu konfiguracnich dat ex. {key=cci,value=3,4,5},{key=macd_1, value=10,2,20} Set[] sets = new Set[keys.size()]; // sets[0] = ImmutableSet.of(keys); int loop = 0; for (String string : keys) { Integer[] values = PropertyHelper.getIntPropertyForOptimizer(string); Integer[] ilist = getAllIntegers(values); sets[loop++] = ImmutableSet.of(ilist); } List<String> reducedKeys = new ArrayList<String>(); for (int i = 0; i < keys.size(); i++) { String s = keys.get(i); s = s.split("\\.")[1]; reducedKeys.add(s); } Set s = Sets.cartesianProduct(sets); System.out.println(s.size()); Iterator it = s.iterator(); loop = 0; while (it.hasNext()) { ImmutableList il = (ImmutableList) it.next(); Object[] o = il.toArray(); map = new HashMap<String, Integer>(); for (int i = 0; i < reducedKeys.size(); i++) { map.put(reducedKeys.get(i), (Integer) o[i]); } list.add(map); } return list; /*map = new HashMap<String, Integer>(); map.put("pt", 40); map.put("sl", 30); map.put("emaslow", 15); map.put("emafast", 5); map.put("cci", 13); map.put("macd_1", 5); map.put("macd_2", 40); map.put("macd_3", 5); list.add(map); map = new HashMap<String, Integer>(); map.put("pt", 50); map.put("sl", 20); map.put("emaslow", 13); map.put("emafast", 3); map.put("cci", 16); map.put("macd_1", 5); map.put("macd_2", 35); map.put("macd_3", 5); list.add(map);*/ }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProductTooBig() { Set<Integer> set = ContiguousSet.create(Range.closed(0, 10000), DiscreteDomain.integers()); try { Sets.cartesianProduct(set, set, set, set, set); fail("Expected IAE"); } catch (IllegalArgumentException expected) { } }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_contains() { Set<List<Integer>> actual = Sets.cartesianProduct(set(1, 2), set(3, 4)); assertTrue(actual.contains(list(1, 3))); assertTrue(actual.contains(list(1, 4))); assertTrue(actual.contains(list(2, 3))); assertTrue(actual.contains(list(2, 4))); assertFalse(actual.contains(list(3, 1))); }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_unrelatedTypes() { Set<Integer> x = set(1, 2); Set<String> y = set("3", "4"); List<Object> exp1 = list((Object) 1, "3"); List<Object> exp2 = list((Object) 1, "4"); List<Object> exp3 = list((Object) 2, "3"); List<Object> exp4 = list((Object) 2, "4"); assertThat(Sets.<Object>cartesianProduct(x, y)) .containsExactly(exp1, exp2, exp3, exp4) .inOrder(); }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_2x2x2() { assertThat(Sets.cartesianProduct(set(0, 1), set(0, 1), set(0, 1))) .containsExactly( list(0, 0, 0), list(0, 0, 1), list(0, 1, 0), list(0, 1, 1), list(1, 0, 0), list(1, 0, 1), list(1, 1, 0), list(1, 1, 1)) .inOrder(); }
@Test public void whenCalculateSetsProduct_thenCorrect() { final Set<Character> first = ImmutableSet.of('a', 'b'); final Set<Character> second = ImmutableSet.of('c', 'd'); final Set<List<Character>> result = Sets.cartesianProduct(ImmutableList.of(first, second)); final Function<List<Character>, String> func = new Function<List<Character>, String>() { @Override public final String apply(final List<Character> input) { return Joiner.on(" ").join(input); } }; final Iterable<String> joined = Iterables.transform(result, func); assertThat(joined, containsInAnyOrder("a c", "a d", "b c", "b d")); }
/** * Creates an iterator that returns an {@link Options} containing each possible parameter set * defined by these {@link * com.biomatters.plugins.barcoding.validator.research.options.BatchOptions}. Note that the {@link * Options} object returned is always the same to save on initializing multiple copies. Each time * {@link java.util.Iterator#next()} is called the next parameter set is set on the {@link * Options}. * * @return An iterator that will iterate over all possible parameter sets specified by this {@link * com.biomatters.plugins.barcoding.validator.research.options.BatchOptions} * @throws DocumentOperationException if there is a problem creating the {@link Options} object */ public Iterator<T> iterator() throws DocumentOperationException { List<Set<OptionToSet>> possibleValues = new ArrayList<Set<OptionToSet>>(); Map<String, MultiValueOption<?>> multiValueOptions = getMultiValueOptions("", options); for (Map.Entry<String, MultiValueOption<?>> entry : multiValueOptions.entrySet()) { possibleValues.add(getOptionsToSet(entry.getKey(), entry.getValue())); } Set<List<OptionToSet>> lists = Sets.cartesianProduct(possibleValues); final Iterator<List<OptionToSet>> possibilityIterator = lists.iterator(); final T template; try { //noinspection unchecked template = (T) options.getClass().newInstance(); // getClass() doesn't return Class<T> :( template.valuesFromXML(options.valuesToXML(XMLSerializable.ROOT_ELEMENT_NAME)); } catch (InstantiationException e) { throw new DocumentOperationException("Failed to create Options: " + e.getMessage(), e); } catch (IllegalAccessException e) { throw new DocumentOperationException("Failed to create Options: " + e.getMessage(), e); } return new Iterator<T>() { @Override public boolean hasNext() { return possibilityIterator.hasNext(); } @Override public T next() { List<OptionToSet> possibility = possibilityIterator.next(); for (OptionToSet optionToSet : possibility) { template.setValue(optionToSet.name, optionToSet.value); } return template; } @Override public void remove() { new UnsupportedOperationException(); } }; }
@Parameterized.Parameters(name = "repetitions={0}, hash={1}") public static Iterable<Object[]> data() { List<HashAlgorithm> hash = ImmutableList.of( DefaultHashAlgorithm.FNV1A_64_HASH, DefaultHashAlgorithm.KETAMA_HASH, MemcachedCache.MURMUR3_128); List<Integer> repetitions = Arrays.asList(160, 500, 1000, 2500, 5000); Set<List<Object>> values = Sets.cartesianProduct(Sets.newLinkedHashSet(hash), Sets.newLinkedHashSet(repetitions)); return Iterables.transform( values, new Function<List<Object>, Object[]>() { @Nullable @Override public Object[] apply(List<Object> input) { return input.toArray(); } }); }
@Override public Set<ImmutableMap<InputPort, Data>> makeProduct( final StepInputPorts inputPorts, final Multimap<InputPort, Data> inputTokens) { checkNotNull(inputPorts, "inputPorts argument cannot be null"); checkNotNull(inputTokens, "inputTokens argument cannot be null"); final Set<ImmutableMap<InputPort, Data>> result = new HashSet<>(); final List<StepInputPort> portsList = Lists.newArrayList(inputPorts.iterator()); // First create the lists for Sets.cartesianProduct() final List<Set<CartesianProductEntry>> sets = new ArrayList<>(); for (StepInputPort port : portsList) { final Set<CartesianProductEntry> s = new HashSet<>(); for (Data d : inputTokens.get(port)) { s.add(new CartesianProductEntry(port, d)); } sets.add(s); } // Compute cartesian product final Set<List<CartesianProductEntry>> cartesianProduct = Sets.cartesianProduct(sets); // Now convert result of cartesianProduct() to final result for (List<CartesianProductEntry> l : cartesianProduct) { final ImmutableMap.Builder<InputPort, Data> imb = ImmutableMap.builder(); for (CartesianProductEntry e : l) { imb.put(e.port, e.data); } result.add(imb.build()); } return result; }
protected void instantiateCandidate( OperatorDescriptorSingle dps, Channel in, List<Set<? extends NamedChannel>> broadcastPlanChannels, List<PlanNode> target, CostEstimator estimator, RequestedGlobalProperties globPropsReq, RequestedLocalProperties locPropsReq) { final PlanNode inputSource = in.getSource(); for (List<NamedChannel> broadcastChannelsCombination : Sets.cartesianProduct(broadcastPlanChannels)) { boolean validCombination = true; boolean requiresPipelinebreaker = false; // check whether the broadcast inputs use the same plan candidate at the branching point for (int i = 0; i < broadcastChannelsCombination.size(); i++) { NamedChannel nc = broadcastChannelsCombination.get(i); PlanNode bcSource = nc.getSource(); // check branch compatibility against input if (!areBranchCompatible(bcSource, inputSource)) { validCombination = false; break; } // check branch compatibility against all other broadcast variables for (int k = 0; k < i; k++) { PlanNode otherBcSource = broadcastChannelsCombination.get(k).getSource(); if (!areBranchCompatible(bcSource, otherBcSource)) { validCombination = false; break; } } // check if there is a common predecessor and whether there is a dam on the way to all // common predecessors if (in.isOnDynamicPath() && this.hereJoinedBranches != null) { for (OptimizerNode brancher : this.hereJoinedBranches) { PlanNode candAtBrancher = in.getSource().getCandidateAtBranchPoint(brancher); if (candAtBrancher == null) { // closed branch between two broadcast variables continue; } SourceAndDamReport res = in.getSource().hasDamOnPathDownTo(candAtBrancher); if (res == NOT_FOUND) { throw new CompilerException("Bug: Tracing dams for deadlock detection is broken."); } else if (res == FOUND_SOURCE) { requiresPipelinebreaker = true; break; } else if (res == FOUND_SOURCE_AND_DAM) { // good } else { throw new CompilerException(); } } } } if (!validCombination) { continue; } if (requiresPipelinebreaker) { in.setTempMode(in.getTempMode().makePipelineBreaker()); } final SingleInputPlanNode node = dps.instantiate(in, this); node.setBroadcastInputs(broadcastChannelsCombination); // compute how the strategy affects the properties GlobalProperties gProps = in.getGlobalProperties().clone(); LocalProperties lProps = in.getLocalProperties().clone(); gProps = dps.computeGlobalProperties(gProps); lProps = dps.computeLocalProperties(lProps); // filter by the user code field copies gProps = gProps.filterBySemanticProperties(getSemanticPropertiesForGlobalPropertyFiltering(), 0); lProps = lProps.filterBySemanticProperties(getSemanticPropertiesForLocalPropertyFiltering(), 0); // apply node.initProperties(gProps, lProps); node.updatePropertiesWithUniqueSets(getUniqueFields()); target.add(node); } }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_hashCode() { // Run through the same cartesian products we tested above Set<List<Integer>> degenerate = Sets.cartesianProduct(); checkHashCode(degenerate); checkHashCode(Sets.cartesianProduct(set(1, 2))); int num = Integer.MAX_VALUE / 3 * 2; // tickle overflow-related problems checkHashCode(Sets.cartesianProduct(set(1, 2, num))); Set<Integer> mt = emptySet(); checkHashCode(Sets.cartesianProduct(mt, mt)); checkHashCode(Sets.cartesianProduct(mt, set(num))); checkHashCode(Sets.cartesianProduct(set(num), mt)); checkHashCode(Sets.cartesianProduct(set(num), set(1))); checkHashCode(Sets.cartesianProduct(set(1), set(2, num))); checkHashCode(Sets.cartesianProduct(set(1, num), set(2, num - 1))); checkHashCode(Sets.cartesianProduct(set(1, num), set(2, num - 1), set(3, num + 1))); // a bigger one checkHashCode( Sets.cartesianProduct(set(1, num, num + 1), set(2), set(3, num + 2), set(4, 5, 6, 7, 8))); }
/** The 0-ary cartesian product is a single empty list. */ @SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_zeroary() { assertThat(Sets.cartesianProduct()).containsExactly(list()); }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_binary2x2() { assertThat(Sets.cartesianProduct(set(1, 2), set(3, 4))) .containsExactly(list(1, 3), list(1, 4), list(2, 3), list(2, 4)) .inOrder(); }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_binary1x1() { assertThat(Sets.cartesianProduct(set(1), set(2))).contains(list(1, 2)); }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_binary1x0() { Set<Integer> mt = emptySet(); assertEmpty(Sets.cartesianProduct(set(1), mt)); }