de.invation.code.toval.misc.SetUtils Maven / Gradle / Ivy

Go to download
package de.invation.code.toval.misc;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.Set;

import de.invation.code.toval.types.HashList;
import de.invation.code.toval.validate.Validate;


public class SetUtils {
	
	private static java.util.Random rand = new Random(); 
	
	/**
	 * Generates a subset of set, that contains a random number of elements.
	 * @param  Type of set elements
	 * @param set Basic set for operation
	 * @return A subset with a random number of elements
	 */
	public static  Set getRandomSubset(Set set){
		return getRandomSubsetMax(set, set.size());
	}
	
	/**
	 * Generates a random subset of set, that contains at most maxCount elements.
	 * @param  Type of set elements
	 * @param set Basic set for operation
	 * @param maxCount Maximum number of items
	 * @return A subset with at most maxCount elements
	 */
	public static  Set getRandomSubsetMax(Set set, int maxCount){
		int count = rand.nextInt(maxCount)+1;
		return getRandomSubset(set, count);	
	}
	
	/**
	 * Generates a random subset of set, that contains at least maxCount elements.
	 * @param  Type of set elements
	 * @param set Basic set for operation
	 * @param minCount Minimum number of items
	 * @return A subset with at least minCount elements
	 */
	public static  Set getRandomSubsetMin(Set set, int minCount){
		int count = RandomUtils.randomIntBetween(minCount, set.size());
		return getRandomSubset(set, count);	
	}
	
	/**
	 * Generates a random subset of set, that contains exactly maxCount elements.
	 * @param  Type of set elements
	 * @param set Basic set for operation
	 * @param count Number of items
	 * @return A subset with exactly count elements
	 */
	public static  Set getRandomSubset(Set set, int count){
		Set result = new HashSet();
		HashList opSet = new HashList(set);
		while(result.size() Type of set elements
	 * @param hashSet Underlying set of elements
	 * @return Powerset of set
	 */
	public static  PowerSet getPowerSet(Set hashSet) {
		Validate.notNull(hashSet);
		if(hashSet.size() == 0)
			throw new IllegalArgumentException("set size 0");
		HashList hashList = new HashList(hashSet);
		PowerSet result = new PowerSet(hashList.size());
		for (int i = 0; i < Math.pow(2, hashList.size()); i++) {
			int setSize = Integer.bitCount(i);
			HashSet newList = new HashSet(setSize);
			result.get(setSize).add(newList);
			for (int j = 0; j < hashList.size(); j++) {
				if ((i & (1 << j)) != 0) {
					newList.add(hashList.get(j));
				}
			}
		}
		return result;
	}
	
	public static synchronized  List> getKElementarySets(Set set, int k) {
		return ListUtils.getKElementaryLists(new ArrayList(set), k);
	}
	
	/**
	 * Basic class for representing a powerset (the set of all subsets of a set).

	 * Subsets are kept in a map grouped by their size which acts as map-key.
	 * map-values are lists of {@link HashSet}s representing the subsets.
	 * @param  Type of set elements
	 * 
	 * @author Thomas Stocker
	 */
	@SuppressWarnings("serial")
	public static class PowerSet extends HashMap>>{
		
		/**
		 * Creates a new PowerSet and prepares the subset-map.
		 * @param setSize The size (number of elements) of the underlying set
		 */
		public PowerSet(int setSize){
			for(int i=0; i<=setSize ; i++) {
				put(i, new ArrayList>());
			}
		}
		
		/**
		 * Returns a String representation of the powerset.
		 * @return String representation of the powerset
		 */
		@Override
		public String toString() {
			StringBuilder builder = new StringBuilder();
			String format = "%s: %s\n";
			for(Integer i: keySet()) {
				builder.append(String.format(format, i, Arrays.toString(get(i).toArray())));
			}
			return builder.toString();
		}
	
	}
	
	/**
	 * Determines the intersection of a collection of sets.
	 * @param sets Basic collection of sets.
	 * @return The set of common elements of all given sets.
	 */
	public static  Set intersection(Collection> sets){
		Set result = new HashSet();
		if(sets.isEmpty()){
			return result;
		}
		Iterator> iter = sets.iterator();
		result.addAll(iter.next());
		while(iter.hasNext()){
			result.retainAll(iter.next());
		}
		return result;
	}
	
	/**
	 * Determines the intersection of a collection of sets.
	 * @param sets Basic collection of sets.
	 * @return The set of common elements of all given sets.
	 */
	public static  Set intersection(Set... sets){
		return intersection(Arrays.asList(sets));
	}
	
	/**
	 * Determines the union of a collection of sets.
	 * @param sets Basic collection of sets.
	 * @return The set of distinct elements of all given sets.
	 */
	public static  Set union(Collection> sets){
		Set result = new HashSet();
		if(sets.isEmpty()){
			return result;
		}
		Iterator> iter = sets.iterator();
		result.addAll(iter.next());
		
		if(sets.size() == 1){
			return result;
		}
		
		while(iter.hasNext()){
			result.addAll(iter.next());
		}
		return result;
	}
	
	public static  Set union(Set... sets){
		List> list = new ArrayList>(sets.length);
		for(Set set: sets){
			list.add(set);
		}
		return union(list);
	}
	
	public static  boolean containSameElements(Collection> sets){
		if(sets.isEmpty() || sets.size()<2)
			return false;
		Iterator> iterator = sets.iterator();
		Set basicSet = iterator.next();
		Set actualSet;
		while(iterator.hasNext()){
			actualSet = iterator.next();
			if(actualSet.size() != basicSet.size())
				return false;
			if(!actualSet.containsAll(basicSet))
				return false;
		}
		return true;
	}
	
	public static  boolean containSameElements(Set... sets){
		if(sets.length == 0 || sets.length<2)
			return false;
		Set basicSet = sets[0];
		for(int i=1; i T getRandomElement(Set set){
		ArrayList list = new ArrayList();
		list.addAll(set);
		return list.get(rand.nextInt(list.size()));
	}
	
	/**
	 * Checks if any two of the given sets intersect.
	 * @param sets Basic collection of sets.
	 * @return true if there is an intersection between at least two sets;

	 * false otherswise.
	 */
	public static boolean existPairwiseIntersections(Collection> sets){
		//Determine all possible pairs of sets
		List>> setPairs = ListUtils.getKElementaryLists(new ArrayList>(sets), 2);
		for(Iterator>> iter = setPairs.iterator(); iter.hasNext();){
			Set intersection = SetUtils.intersection(iter.next());
			if(!intersection.isEmpty()){
				return true;
			}
		}
		return false;
	}

}