/** * This method generates all the ways of dividing totalNodes into two sets * each containing at least one node. It will generate one set for each * possible partitioning. The other partition is implied in the absent values. * In order not to generate the inverse of any set, we always include the 0th * node in our sets. * * @return A set of sets each of which defines a partitioning of totalNodes */ @VisibleForTesting static Set<Set<Integer>> generatePartitions(int totalNodes) { checkArgument(totalNodes > 1, "totalNodes must be greater than 1"); Set<Integer> numbers = IntStream.range(0, totalNodes) .boxed() .collect(toImmutableSet()); return powerSet(numbers).stream() .filter(subSet -> subSet.contains(0)) .filter(subSet -> subSet.size() < numbers.size()) .collect(toImmutableSet()); }
public void testPowerSetShowOff() { Set<Object> zero = ImmutableSet.of(); Set<Set<Object>> one = powerSet(zero); Set<Set<Set<Object>>> two = powerSet(one); Set<Set<Set<Set<Object>>>> four = powerSet(two); Set<Set<Set<Set<Set<Object>>>>> sixteen = powerSet(four); Set<Set<Set<Set<Set<Set<Object>>>>>> sixtyFiveThousandish = powerSet(sixteen); assertEquals(1 << 16, sixtyFiveThousandish.size()); assertTrue(powerSet(makeSetOfZeroToTwentyNine()).contains(makeSetOfZeroToTwentyNine())); assertFalse(powerSet(makeSetOfZeroToTwentyNine()).contains(ImmutableSet.of(30))); }
private static void assertPowerSetSize(int i, Object... elements) { assertEquals(i, powerSet(newHashSet(elements)).size()); }
public void testPowerSetIteration_iteratorTester_fast() { ImmutableSet<Integer> elements = ImmutableSet.of(1, 2); Set<Set<Integer>> expected = newLinkedHashSet(); expected.add(ImmutableSet.<Integer>of()); expected.add(ImmutableSet.of(1)); expected.add(ImmutableSet.of(2)); expected.add(ImmutableSet.of(1, 2)); final Set<Set<Integer>> powerSet = powerSet(elements); new IteratorTester<Set<Integer>>(4, UNMODIFIABLE, expected, KNOWN_ORDER) { @Override protected Iterator<Set<Integer>> newTargetIterator() { return powerSet.iterator(); } }.test(); }
private static void assertPowerSetHashCode(int expected, Set<?> elements) { assertEquals(expected, powerSet(elements).hashCode()); }
partialSets.add(ImmutableList.copyOf(Sets.powerSet(cube)));
@GwtIncompatible // too slow for GWT public void testPowerSetIteration_iteratorTester() { ImmutableSet<Integer> elements = ImmutableSet.of(1, 2); Set<Set<Integer>> expected = newLinkedHashSet(); expected.add(ImmutableSet.<Integer>of()); expected.add(ImmutableSet.of(1)); expected.add(ImmutableSet.of(2)); expected.add(ImmutableSet.of(1, 2)); final Set<Set<Integer>> powerSet = powerSet(elements); new IteratorTester<Set<Integer>>(6, UNMODIFIABLE, expected, KNOWN_ORDER) { @Override protected Iterator<Set<Integer>> newTargetIterator() { return powerSet.iterator(); } }.test(); }
public void testPowerSetEmpty() { ImmutableSet<Integer> elements = ImmutableSet.of(); Set<Set<Integer>> powerSet = powerSet(elements); assertEquals(1, powerSet.size()); assertEquals(ImmutableSet.of(ImmutableSet.of()), powerSet); assertEquals(0, powerSet.hashCode()); }
public void testPowerSetCreationErrors() { try { Set<Set<Character>> unused = powerSet( newHashSet( 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5')); fail(); } catch (IllegalArgumentException expected) { } try { Set<Set<Integer>> unused = powerSet(ContiguousSet.closed(0, Integer.MAX_VALUE / 2)); fail(); } catch (IllegalArgumentException expected) { } try { powerSet(singleton(null)); fail(); } catch (NullPointerException expected) { } }
public void testContainsAll() { ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) { assertTrue(set.containsAll(subset)); } for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) { assertFalse(set.containsAll(Sets.union(subset, ImmutableSet.of(9)))); } assertFalse(set.containsAll((Collection<?>) ImmutableSet.of("blah"))); }
public void testPowerSetIteration_manual() { ImmutableSet<Integer> elements = ImmutableSet.of(1, 2, 3); Set<Set<Integer>> powerSet = powerSet(elements); // The API doesn't promise this iteration order, but it's convenient here. Iterator<Set<Integer>> i = powerSet.iterator(); assertEquals(ImmutableSet.of(), i.next()); assertEquals(ImmutableSet.of(1), i.next()); assertEquals(ImmutableSet.of(2), i.next()); assertEquals(ImmutableSet.of(2, 1), i.next()); assertEquals(ImmutableSet.of(3), i.next()); assertEquals(ImmutableSet.of(3, 1), i.next()); assertEquals(ImmutableSet.of(3, 2), i.next()); assertEquals(ImmutableSet.of(3, 2, 1), i.next()); assertFalse(i.hasNext()); try { i.next(); fail(); } catch (NoSuchElementException expected) { } }
public void testPowerSetContents() { ImmutableSet<Integer> elements = ImmutableSet.of(1, 2, 3); Set<Set<Integer>> powerSet = powerSet(elements); assertEquals(8, powerSet.size()); assertEquals(4 * 1 + 4 * 2 + 4 * 3, powerSet.hashCode()); Set<Set<Integer>> expected = newHashSet(); expected.add(ImmutableSet.<Integer>of()); expected.add(ImmutableSet.of(1)); expected.add(ImmutableSet.of(2)); expected.add(ImmutableSet.of(3)); expected.add(ImmutableSet.of(1, 2)); expected.add(ImmutableSet.of(1, 3)); expected.add(ImmutableSet.of(2, 3)); expected.add(ImmutableSet.of(1, 2, 3)); Set<Set<Integer>> almostPowerSet = newHashSet(expected); almostPowerSet.remove(ImmutableSet.of(1, 2, 3)); almostPowerSet.add(ImmutableSet.of(1, 2, 4)); new EqualsTester() .addEqualityGroup(expected, powerSet) .addEqualityGroup(ImmutableSet.of(1, 2, 3)) .addEqualityGroup(almostPowerSet) .testEquals(); for (Set<Integer> subset : expected) { assertTrue(powerSet.contains(subset)); } assertFalse(powerSet.contains(ImmutableSet.of(1, 2, 4))); assertFalse(powerSet.contains(singleton(null))); assertFalse(powerSet.contains(null)); assertFalse(powerSet.contains((Object) "notASet")); }
public void testCombinations() { ImmutableList<Set<Integer>> sampleSets = ImmutableList.<Set<Integer>>of( ImmutableSet.<Integer>of(), ImmutableSet.of(1, 2), ImmutableSet.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)); for (Set<Integer> sampleSet : sampleSets) { for (int k = 0; k <= sampleSet.size(); k++) { final int size = k; Set<Set<Integer>> expected = Sets.filter( Sets.powerSet(sampleSet), new Predicate<Set<Integer>>() { @Override public boolean apply(Set<Integer> input) { return input.size() == size; } }); assertThat(Sets.combinations(sampleSet, k)) .named("Sets.combinations(%s, %s)", sampleSet, k) .containsExactlyElementsIn(expected) .inOrder(); } } }
public void testPowerSetEqualsAndHashCode_verifyAgainstHashSet() { ImmutableList<Integer> allElements = ImmutableList.of( 4233352, 3284593, 3794208, 3849533, 4013967, 2902658, 1886275, 2131109, 985872, 1843868); for (int i = 0; i < allElements.size(); i++) { Set<Integer> elements = newHashSet(allElements.subList(0, i)); Set<Set<Integer>> powerSet1 = powerSet(elements); Set<Set<Integer>> powerSet2 = powerSet(elements); new EqualsTester() .addEqualityGroup(powerSet1, powerSet2, toHashSets(powerSet1)) .addEqualityGroup(ImmutableSet.of()) .addEqualityGroup(ImmutableSet.of(9999999)) .addEqualityGroup("notASet") .testEquals(); assertEquals(toHashSets(powerSet1).hashCode(), powerSet1.hashCode()); } }
/** * Compiles all combination of available features and stores them in two maps for * lookup based on a unique hash of features. */ private void registerAllShaderPermutations() { Set<Set<ShaderProgramFeature>> allPermutations = Sets.powerSet(availableFeatures); for (Set<ShaderProgramFeature> permutation : allPermutations) { int fragShaderId = compileShader(GL20.GL_FRAGMENT_SHADER, permutation); int vertShaderId = compileShader(GL20.GL_VERTEX_SHADER, permutation); if (compileSuccess(fragShaderId) && compileSuccess(vertShaderId)) { int featureHash = ShaderProgramFeature.getBitset(permutation); disposalAction.fragmentPrograms.put(featureHash, fragShaderId); disposalAction.vertexPrograms.put(featureHash, vertShaderId); } else { throw new RuntimeException(String.format("Shader '%s' failed to compile for features '%s'.%n%n" + "Vertex Shader Info: %n%s%n" + "Fragment Shader Info: %n%s", getUrn(), permutation, getLogInfo(vertShaderId), getLogInfo(fragShaderId))); } } logger.debug("Compiled {} permutations for {}.", allPermutations.size(), getUrn()); }
allValues.addAll(nullFlavors); for (Set<Map<String, Object>> subset : Sets.powerSet(allValues)) { if (subset.isEmpty()) { continue;
@Override public void recompile() { TIntIntIterator it = disposalAction.shaderPrograms.iterator(); while (it.hasNext()) { it.advance(); GL20.glDeleteProgram(it.value()); } disposalAction.shaderPrograms.clear(); uniformLocationMap.clear(); bindMap.clear(); disposalAction.shaderPrograms.put(0, shader.linkShaderProgram(0)); for (Set<ShaderProgramFeature> permutation : Sets.powerSet(shader.getAvailableFeatures())) { int featureMask = ShaderProgramFeature.getBitset(permutation); disposalAction.shaderPrograms.put(featureMask, shader.linkShaderProgram(featureMask)); } //resolves #966 //Some of the uniforms are not updated constantly between frames //this function will rebind any uniforms that are not bound rebindVariables(materialData); }
Set<Set<Integer>> variants = Sets.powerSet(indexes); for (Set<Integer> variantSet : variants) { List<Integer> variant = new ArrayList<Integer>(variantSet);
Range.open(3, 4)); subsets: for (Set<Range<Integer>> subset : Sets.powerSet(ranges)) { assertEquals(TreeRangeSet.create(subset), ImmutableRangeSet.unionOf(subset));
public void testPowerSetEmpty() { ImmutableSet<Integer> elements = ImmutableSet.of(); Set<Set<Integer>> powerSet = powerSet(elements); assertEquals(1, powerSet.size()); assertEquals(ImmutableSet.of(ImmutableSet.of()), powerSet); assertEquals(0, powerSet.hashCode()); }