From 5523f0060903823e2770b727f3a0c0de6c46a39b Mon Sep 17 00:00:00 2001
From: "pablo.rodriguez.mier" <pablo.rodriguez.mier@usc.es>
Date: Fri, 21 Jun 2013 09:58:56 +0200
Subject: [PATCH] New Parallel class provides some functionality to work with
 parallel processing. ParallelSetCover and IterativeSetCover implementations
 added. Close #46

---
 .../combinatorial/IterativeSetCover.java      | 279 ++++++++++++++
 .../combinatorial/ParallelSetCover.java       | 359 ++++++++++++++++++
 .../lab/hipster/util/parallel/Parallel.java   | 313 +++++++++++++++
 .../combinatorial/IterativeSetCoverTest.java  |  20 +
 4 files changed, 971 insertions(+)
 create mode 100644 src/main/java/es/usc/citius/lab/hipster/algorithm/combinatorial/IterativeSetCover.java
 create mode 100644 src/main/java/es/usc/citius/lab/hipster/algorithm/combinatorial/ParallelSetCover.java
 create mode 100644 src/main/java/es/usc/citius/lab/hipster/util/parallel/Parallel.java
 create mode 100644 src/test/java/es/usc/citius/lab/hipster/algorithm/combinatorial/IterativeSetCoverTest.java

diff --git a/src/main/java/es/usc/citius/lab/hipster/algorithm/combinatorial/IterativeSetCover.java b/src/main/java/es/usc/citius/lab/hipster/algorithm/combinatorial/IterativeSetCover.java
new file mode 100644
index 0000000..9b45f18
--- /dev/null
+++ b/src/main/java/es/usc/citius/lab/hipster/algorithm/combinatorial/IterativeSetCover.java
@@ -0,0 +1,279 @@
+package es.usc.citius.lab.hipster.algorithm.combinatorial;
+
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Queue;
+import java.util.Set;
+import java.util.TreeMap;
+
+
+/**
+ * This class computes all combinations of sets that covers all of the possible
+ * elements. Combinations of sets that does not provide new information are not
+ * considered. The implementation of the class relies on BitSet class and
+ * performs logic operations between bits. The generation of the combinations is
+ * done using a Breadth First Search.
+ * 
+ * @author Pablo Rodríguez Mier <pablo.rodriguez.mier@usc.es>
+ * 
+ * @param <E>
+ */
+public class IterativeSetCover<E> implements Iterator<Set<Set<E>>> {
+
+	// Ordered map (descending by key) with the available sets
+	// ordered by size and mapped back to their bitset representation
+	private TreeMap<Set<E>, BitSet> orderedSets;
+	// Maps bitset with their set representation
+	private Map<BitSet, Set<E>> bitsetMap;
+	// List of subsets, ordered by size
+	private List<BitSet> bitsetList;
+	// Holds an ordered list with all possible elements
+	private List<E> elements;
+	// Bit size used to store the information of all elements
+	private int size;
+
+	// Iterator
+	private Iterator<Set<Set<E>>> iterator;
+
+	private class State {
+		State previous;
+		BitSet selected;
+		BitSet statebits;		
+
+		public State() {
+			this.previous = null;
+			this.selected = new BitSet(size);
+			this.statebits = new BitSet(size);
+		}
+
+		public State(State previous, BitSet selected) {
+			this.previous = previous;
+			this.selected = selected;
+			this.statebits = new BitSet(size);
+			this.statebits.or(previous.statebits);
+			this.statebits.or(selected);
+		}
+
+		boolean isFinal() {
+			return this.statebits.cardinality() == size;
+		}
+
+		Set<Set<E>> stateSets() {
+			Set<Set<E>> combination = new HashSet<Set<E>>();
+			combination.add(bitsetMap.get(this.selected));
+			State parent = previous;
+			while (parent != null) {
+				Set<E> set = bitsetMap.get(parent.selected);
+				if (set != null && !set.isEmpty()) {
+					combination.add(set);
+				}
+				parent = parent.previous;
+			}
+			return combination;
+		}
+		
+		
+		Set<State> candidates() {
+			Set<State> candidateStates = new HashSet<State>();
+			Set<BitSet> candidates = new HashSet<BitSet>();
+			// Now, select all those bitsets with a bigger index
+			// which sets some bits of the current bitset
+			int from = bitsetList.indexOf(this.selected);
+			// If position = -1, start from 0
+			from = (from < 0) ? 0 : from;
+			List<Integer> zeros = findBitIndex(this.statebits, false);
+			for (Integer i : zeros) {
+				Set<BitSet> c = findByColumn(from, i, true);
+				// If there is no candidate for the current bit
+				// then this branch is not solvable
+				if (c.isEmpty()){
+					return Collections.emptySet();
+				}
+				candidates.addAll(c);
+			}
+			for(BitSet c : candidates){
+				candidateStates.add(new State(this, c));
+			}
+			candidates.clear();
+			return candidateStates;
+		}
+
+		
+
+	}
+
+	public IterativeSetCover(Set<Set<E>> sets) {
+		this.elements = elements(sets);
+		this.bitsetList = new ArrayList<BitSet>();
+		
+		this.size = this.elements.size();
+		this.orderedSets = new TreeMap<Set<E>, BitSet>(
+				new Comparator<Set<E>>() {
+					public int compare(Set<E> o1, Set<E> o2) {
+						if (o2.size() > o1.size()) {
+							return 1;
+						}
+						return -1;
+					}
+				});
+		this.bitsetMap = new HashMap<BitSet, Set<E>>();
+
+		// Initialize the values of the bitset list
+		// (there are m sets)
+		for (Set<E> set : sets) {
+			// Create a set of n bits (1 bit per element)
+			BitSet b = new BitSet(this.size);
+			for (int j = 0; j < this.size; j++) {
+				// b(j)=1 if the element j appears on set(i)
+				b.set(j, set.contains(this.elements.get(j)));
+			}
+			this.orderedSets.put(set, b);
+			this.bitsetMap.put(b, set);
+		}
+
+		// Insert ordered bitsets into a list
+		for (Entry<Set<E>, BitSet> entry : this.orderedSets.entrySet()) {
+			this.bitsetList.add(entry.getValue());
+		}
+		this.iterator = enumerate().iterator();
+	}
+
+	private Comparator<BitSet> bitComparator(final BitSet source) {
+		return new Comparator<BitSet>() {
+
+			public int compare(BitSet o1, BitSet o2) {
+				// Check how many bits of source are changed
+				BitSet original = new BitSet();
+				original.or(source);
+				// Test o1
+				original.or(o1);
+				Integer sizeO1 = original.size();
+				// Reset original bitset
+				original.xor(original);
+				original.or(source);
+				original.or(o2);
+				Integer sizeO2 = original.size();
+				if (sizeO1 > sizeO2) {
+					return 1;
+				}
+				return -1;
+			}
+		};
+	}
+
+	
+	/**
+	 * Return BitSets with the bit at position = value
+	 * 
+	 * @param value
+	 *            True (1) false (0)
+	 */
+	public Set<BitSet> findByColumn(Collection<BitSet> bitsets, int position,
+			boolean value) {
+		Set<BitSet> rows = new HashSet<BitSet>();
+		// Find rows with ones in that position
+		for (BitSet b : bitsets) {
+			if (b.get(position) == value) {
+				rows.add(b);
+			}
+		}
+		return rows;
+	}
+
+	public Set<BitSet> findByColumn(int fromIndex, int bitPosition,
+			boolean value) {
+		Set<BitSet> rows = new HashSet<BitSet>();
+		for (int i = fromIndex; i < this.bitsetList.size(); i++) {
+			BitSet current = this.bitsetList.get(i);
+			if (current.get(bitPosition) == value) {
+				rows.add(current);
+			}
+		}
+		return rows;
+	}
+
+	public List<Integer> findBitIndex(BitSet bitset, boolean value) {
+		List<Integer> indexes = new ArrayList<Integer>();
+		for (int i = 0; i < this.size; i++) {
+			if (bitset.get(i) == value) {
+				indexes.add(i);
+			}
+		}
+		return indexes;
+	}
+
+	// TODO: Optimize this function.
+	private boolean isDominated(Collection<Set<Set<E>>> solutions,
+			Set<Set<E>> candidate) {
+		for (Set<Set<E>> solution : solutions) {
+			// Check if this combination is worse. If a valid combination
+			// has less length than the current combination, check if the
+			// valid combination is a subset of combination.
+			if (solution.size() < candidate.size()) {
+				if (candidate.containsAll(solution)) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	private List<E> elements(Collection<Set<E>> sets) {
+		Set<E> universe = new HashSet<E>();
+		for (Set<E> set : sets) {
+			universe.addAll(set);
+		}
+		return new ArrayList<E>(universe);
+	}
+
+	public Collection<Set<Set<E>>> enumerate() {
+		Collection<Set<Set<E>>> solutions = new LinkedHashSet<Set<Set<E>>>();
+		// Queue used for BFS
+		Queue<State> queue = new LinkedList<State>();
+		// Root element
+		queue.add(new State());
+
+		// Breadth-First-Search
+		while (!queue.isEmpty()) {
+			State next = queue.poll();
+			// Check if some candidate is final
+			for (State candidate : next.candidates()) {
+				// Discard this candidate if dominated
+				Set<Set<E>> candidateSets = candidate.stateSets();
+				if (!isDominated(solutions, candidateSets)) {
+					if (candidate.isFinal()) {
+						// add it as a final
+						solutions.add(candidateSets);
+					} else {
+						queue.add(candidate);
+					}
+				}
+			}
+		}
+		return solutions;
+	}
+
+	public boolean hasNext() {
+		return iterator.hasNext();
+	}
+
+	public Set<Set<E>> next() {
+		return iterator.next();
+	}
+
+	public void remove() {
+		iterator.remove();
+	}
+
+}
diff --git a/src/main/java/es/usc/citius/lab/hipster/algorithm/combinatorial/ParallelSetCover.java b/src/main/java/es/usc/citius/lab/hipster/algorithm/combinatorial/ParallelSetCover.java
new file mode 100644
index 0000000..3808876
--- /dev/null
+++ b/src/main/java/es/usc/citius/lab/hipster/algorithm/combinatorial/ParallelSetCover.java
@@ -0,0 +1,359 @@
+package es.usc.citius.lab.hipster.algorithm.combinatorial;
+
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Queue;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.concurrent.ExecutionException;
+
+import es.usc.citius.lab.hipster.util.parallel.Parallel;
+
+
+
+/**
+ * This class computes all combinations of sets that covers all of the possible
+ * elements. Combinations of sets that does not provide new information are not
+ * considered. The implementation of the class relies on BitSet class and
+ * performs logic operations between bits. The generation of the combinations is
+ * done using a Parallelized Breadth-First-Search.<br>
+ * <br>
+ * <b>Example:</b><br>
+ * Suppose you have the following sets: 1={a,c}, 2={a,b}, 3={c}, 4={d},
+ * 5={a,b,d}. <br>
+ * 
+ * Then, the goal is to find the whole combinations of sets that cover all
+ * elements (a,b,c,d).
+ * <ul>
+ * <li>3 + 5 ({c} U {a,b,e}) it's a valid solution, which uses two sets (3 and
+ * 5).</li>
+ * <li>1 + 5 it's a valid solution, which uses two sets (1 and 5).</li>
+ * <li>2 + 3 + 5 it's not a valid solution since there exist a solution which
+ * takes only sets 3 and 5, thus set 2 is not required and does not provide new
+ * information. This combination is redundant.</li>
+ * </ul>
+ * 
+ * This problem is based on the SCP (Set Cover Problem) but it does not find the
+ * combination with the minimum number of sets. Instead, it enumerates all
+ * possible combinations that cover all elements discarding redundant solutions.
+ * For more information read <a
+ * href="http://en.wikipedia.org/wiki/Set_cover_problem"
+ * >http://en.wikipedia.org/wiki/Set_cover_problem</a>
+ * 
+ * @author Pablo Rodríguez Mier <pablo.rodriguez.mier@usc.es>
+ * 
+ * @param <E>
+ */
+public class ParallelSetCover<E> implements Iterator<Set<Set<E>>> {
+
+	// Ordered map (descending by key) with the available sets
+	// ordered by size and mapped back to their bitset representation
+	private final TreeMap<Set<E>, BitSet> orderedSets;
+	// Maps bitset with their set representation
+	private final Map<BitSet, Set<E>> bitsetMap;
+	// List of subsets, ordered by size
+	private final List<BitSet> bitsetList;
+	// Holds an ordered list with all possible elements
+	private final List<E> elements;
+	// Bit size used to store the information of all elements
+	private int size;
+	// This collection stores the solutions found
+	private List<Set<Set<E>>> solutions;
+	// Queue used for BFS. A synchronized queue is not required
+	private Queue<State> queue;
+	// Next element index
+	private int nextElementIndex = 0;
+	private Set<Set<E>> nextElement = null;
+
+	/**
+	 * Class Result is used to store the information obtained for each thread
+	 * while performing the BFS
+	 * 
+	 */
+	private class Result {
+		Set<State> candidates;
+		Collection<Set<Set<E>>> solutions;
+
+		Result(Set<State> candidates, Collection<Set<Set<E>>> solutions) {
+			this.candidates = candidates;
+			this.solutions = solutions;
+		}
+	}
+
+	/**
+	 * State class is used to represent a state node during the search. A state
+	 * is defined by a set of bits (statebits) that indicates which elements are
+	 * selected upon this state, a set of bits (selected) that indicates the
+	 * movement (the set selected) and the previous state.<br>
+	 * <br>
+	 * Example:<br>
+	 * from State1 (initial) to State2 selecting {a,d} <br>
+	 * Elements = {a,b,c,d} (4 bits)<br>
+	 * State1 = {previous=null, selected=0000, statebits=0000}<br>
+	 * State2 = {previous=State1, selected=1001 (a,d), statebits=1001 (0000 | 1001)}
+	 * 
+	 */
+	private class State {
+		State previous;
+		BitSet selected;
+		BitSet statebits;
+
+		public State() {
+			this.previous = null;
+			this.selected = new BitSet(size);
+			this.statebits = new BitSet(size);
+		}
+
+		public State(State previous, BitSet selected) {
+			this.previous = previous;
+			this.selected = selected;
+			this.statebits = new BitSet(size);
+			this.statebits.or(previous.statebits);
+			this.statebits.or(selected);
+		}
+
+		boolean isFinal() {
+			return this.statebits.cardinality() == size;
+		}
+
+		Set<Set<E>> stateSets() {
+			Set<Set<E>> combination = new HashSet<Set<E>>();
+			combination.add(bitsetMap.get(this.selected));
+			State parent = previous;
+			while (parent != null) {
+				Set<E> set = bitsetMap.get(parent.selected);
+				if (set != null && !set.isEmpty()) {
+					combination.add(set);
+				}
+				parent = parent.previous;
+			}
+			return combination;
+		}
+
+		Set<State> candidates() {
+			Set<State> candidateStates = new HashSet<State>();
+			Set<BitSet> candidates = new HashSet<BitSet>();
+			// Now, select all those bitsets with a bigger index
+			// which sets some bits of the current bitset
+			int from = bitsetList.indexOf(this.selected);
+			// If position = -1, start from 0
+			from = (from < 0) ? 0 : from;
+			List<Integer> zeros = findBitIndex(this.statebits, false);
+			for (Integer i : zeros) {
+				Set<BitSet> c = findByColumn(from, i, true);
+				// If there is no candidate for the current bit
+				// then this branch is not solvable
+				if (c.isEmpty()) {
+					return Collections.emptySet();
+				}
+				candidates.addAll(c);
+			}
+			for (BitSet c : candidates) {
+				candidateStates.add(new State(this, c));
+			}
+			candidates.clear();
+			return candidateStates;
+		}
+
+	}
+
+	public ParallelSetCover(Set<Set<E>> sets)
+			throws InterruptedException, ExecutionException {
+
+		this.solutions = new LinkedList<Set<Set<E>>>();
+		// Obtain the elements from the sets
+		this.elements = elements(sets);
+		this.bitsetList = new ArrayList<BitSet>();
+		this.size = this.elements.size();
+		// Sort the collection of sets by the their size
+		this.orderedSets = new TreeMap<Set<E>, BitSet>(
+				new Comparator<Set<E>>() {
+					public int compare(Set<E> o1, Set<E> o2) {
+						if (o2.size() > o1.size()) {
+							return 1;
+						}
+						return -1;
+					}
+				});
+
+		this.bitsetMap = new HashMap<BitSet, Set<E>>();
+
+		// Initialize the values of the bitset list (there are m sets)
+		for (Set<E> set : sets) {
+			// Create a set of n bits (1 bit per element)
+			BitSet b = new BitSet(this.size);
+			for (int j = 0; j < this.size; j++) {
+				// b(j)=1 if the element j appears on set(i)
+				b.set(j, set.contains(this.elements.get(j)));
+			}
+			this.orderedSets.put(set, b);
+			this.bitsetMap.put(b, set);
+		}
+
+		// Insert ordered bitsets into a list
+		for (Entry<Set<E>, BitSet> entry : this.orderedSets.entrySet()) {
+			this.bitsetList.add(entry.getValue());
+		}
+
+		// Initialize the queue and put the first states to explore
+		this.queue = new LinkedList<State>(new State().candidates());
+
+	}
+
+	/**
+	 * Return BitSets with the bit at position = value
+	 * 
+	 * @param value
+	 *            True (1) false (0)
+	 */
+	public Set<BitSet> findByColumn(Collection<BitSet> bitsets, int position,
+			boolean value) {
+		Set<BitSet> rows = new HashSet<BitSet>();
+		// Find rows with ones in that position
+		for (BitSet b : bitsets) {
+			if (b.get(position) == value) {
+				rows.add(b);
+			}
+		}
+		return rows;
+	}
+
+	public Set<BitSet> findByColumn(int fromIndex, int bitPosition,
+			boolean value) {
+		Set<BitSet> rows = new HashSet<BitSet>();
+		for (int i = fromIndex; i < this.bitsetList.size(); i++) {
+			BitSet current = this.bitsetList.get(i);
+			if (current.get(bitPosition) == value) {
+				rows.add(current);
+			}
+		}
+		return rows;
+	}
+
+	public List<Integer> findBitIndex(BitSet bitset, boolean value) {
+		List<Integer> indexes = new ArrayList<Integer>();
+		for (int i = 0; i < this.size; i++) {
+			if (bitset.get(i) == value) {
+				indexes.add(i);
+			}
+		}
+		return indexes;
+	}
+
+	// TODO: Optimize this function.
+	private boolean isDominated(Collection<Set<Set<E>>> solutions,
+			Set<Set<E>> candidate) {
+		for (Set<Set<E>> solution : solutions) {
+			// Check if this combination is worse. If a valid combination
+			// has less length than the current combination, check if the
+			// valid combination is a subset of combination.
+			if (solution.size() < candidate.size()) {
+				if (candidate.containsAll(solution)) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	private List<E> elements(Collection<Set<E>> sets) {
+		Set<E> universe = new HashSet<E>();
+		for (Set<E> set : sets) {
+			universe.addAll(set);
+		}
+		return new ArrayList<E>(universe);
+	}
+
+	/**
+	 * Parallelized version of the Iterative Set Cover
+	 * 
+	 * @return Iterator with all combinations of sets
+	 * @throws ExecutionException
+	 * @throws InterruptedException
+	 */
+	public Collection<Set<Set<E>>> enumerate() throws InterruptedException,
+			ExecutionException {
+
+		return solutions;
+
+	}
+
+	public boolean hasNext() {
+
+		// Breadth-First-Search, parallelized and synchronized by levels.
+		// In each step, take all states in the same level, process them and
+		// collect all new candidate states to process in the next step
+
+		while (this.solutions.size() <= this.nextElementIndex
+				&& !this.queue.isEmpty()) {
+
+			Collection<Result> nextLevel = null;
+			try {
+
+				nextLevel = new Parallel.ForEach<State, Result>(queue)
+						.apply(new Parallel.F<State, Result>() {
+							public Result apply(State state) {
+								Set<State> candidates = new HashSet<State>();
+								Collection<Set<Set<E>>> localSolutions = new HashSet<Set<Set<E>>>();
+								for (State candidate : state.candidates()) {
+									Set<Set<E>> candidateSets = candidate
+											.stateSets();
+									if (!isDominated(solutions, candidateSets)) {
+										if (candidate.isFinal()) {
+											localSolutions.add(candidateSets);
+										} else {
+											candidates.add(candidate);
+										}
+									}
+								}
+								return new Result(candidates, localSolutions);
+
+							}
+						}).values();
+
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			} catch (ExecutionException e) {
+				e.printStackTrace();
+			}
+
+			// Empty the queue
+			queue.clear();
+
+			// Take the results obtained by each thread
+			for (Result result : nextLevel) {
+				this.queue.addAll(result.candidates);
+				this.solutions.addAll(result.solutions);
+			}
+		}
+		// Get the next solution
+		// TODO: Solutions cannot be removed!!!!!!
+		if (this.nextElementIndex < solutions.size()) {
+			this.nextElement = solutions.get(this.nextElementIndex);
+			this.nextElementIndex++;
+		} else {
+			this.nextElement = null;
+		}
+
+		return this.nextElement != null;
+	}
+
+	public Set<Set<E>> next() {
+		return this.nextElement;
+	}
+
+	public void remove() {
+		throw new UnsupportedOperationException();
+	}
+
+}
diff --git a/src/main/java/es/usc/citius/lab/hipster/util/parallel/Parallel.java b/src/main/java/es/usc/citius/lab/hipster/util/parallel/Parallel.java
new file mode 100644
index 0000000..8c3a8c7
--- /dev/null
+++ b/src/main/java/es/usc/citius/lab/hipster/util/parallel/Parallel.java
@@ -0,0 +1,313 @@
+/*
+ * Copyright (C) 2012 University of Santiago de Compostela
+ * Centro de Investigación en Tecnoloxías da Información (CITIUS)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package es.usc.citius.lab.hipster.util.parallel;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * <p>
+ * This class contains some useful classes and methods to parallelize code in an
+ * easy and fluent way. Parallel class is self-contained to enable an easier
+ * integration and reuse in different java projects.<br>
+ * 
+ * Code example:<br>
+ * 
+ * <pre>
+ * new ForEach&lt;String, String&gt;(elements).apply(new Function&lt;String&gt;() {
+ * 	public String apply(String element) {
+ * 		System.out.println(element);
+ * 	}
+ * }).values();
+ * </pre>
+ * 
+ * @author Pablo Rodríguez Mier
+ * @version 13.01, 26 Jan 2013
+ */
+public class Parallel {
+
+	private Parallel() {
+		throw new RuntimeException("Not instantiable");
+	}
+
+	/**
+	 * First-order function interface
+	 * 
+	 * @author pablo.rodriguez.mier
+	 * 
+	 * @param <E>
+	 *            Element to transform
+	 * @param <V>
+	 *            Result of the transformation
+	 */
+
+	public static interface F<E, V> {
+		/**
+		 * Apply a function over the element e.
+		 * 
+		 * @param e
+		 *            Input element
+		 * @return transformation result
+		 */
+		V apply(E e);
+	}
+
+	/**
+	 * Action class can be used to define a concurrent task that does not return
+	 * any value after processing the element.
+	 * 
+	 * @param <E>
+	 *            Element processed within the action
+	 */
+	public static abstract class Action<E> implements F<E, Void> {
+
+		/**
+		 * This method is final and cannot be overridden. It applies the action
+		 * implemented by {@link Action#doAction(Object)}.
+		 */
+		public final Void apply(E element) {
+			doAction(element);
+			return null;
+		}
+
+		/**
+		 * Defines the action that will be applied over the element. Every
+		 * action must implement this method.
+		 * 
+		 * @param element
+		 *            element to process
+		 */
+		public abstract void doAction(E element);
+	}
+
+	/**
+	 * This class provides some useful methods to handle the execution of a
+	 * collection of tasks.
+	 * 
+	 * @param <V>
+	 *            value of the task
+	 */
+	public static class TaskHandler<V> {
+		private Collection<Future<V>> runningTasks = new LinkedList<Future<V>>();
+		private ExecutorService executorService;
+
+		public TaskHandler(ExecutorService executor,
+				Collection<Callable<V>> tasks) {
+
+			this.executorService = executor;
+
+			for (Callable<V> task : tasks) {
+				runningTasks.add(executor.submit(task));
+			}
+		}
+
+		/**
+		 * Get the current tasks (futures) that are being executed.
+		 * 
+		 * @return Collection of futures
+		 * @see Future
+		 */
+		public Collection<Future<V>> tasks() {
+			return this.runningTasks;
+		}
+
+		/**
+		 * This function is equivalent to
+		 * {@link ExecutorService#awaitTermination(long, TimeUnit)}
+		 * 
+		 * @see ExecutorService#awaitTermination(long, TimeUnit)
+		 */
+		public boolean wait(long timeout, TimeUnit unit)
+				throws InterruptedException {
+			return this.executorService.awaitTermination(timeout, unit);
+		}
+
+		/**
+		 * Retrieves the result of the transformation of each element (the value
+		 * of each Future). This function blocks until all tasks are terminated.
+		 * 
+		 * @return a collection with the results of the elements transformation
+		 * @throws InterruptedException
+		 * @throws ExecutionException
+		 */
+		public Collection<V> values() throws InterruptedException,
+				ExecutionException {
+			Collection<V> results = new LinkedList<V>();
+			for (Future<V> future : this.runningTasks) {
+				results.add(future.get());
+			}
+			return results;
+		}
+	}
+
+	/**
+	 * 
+	 * @param <E>
+	 * @param <V>
+	 */
+	public static class ForEach<E, V> implements F<F<E, V>, TaskHandler<V>> {
+		// Source elements
+		private Iterable<E> elements;
+		// Executor used to invoke concurrent tasks. By default it uses as many
+		// threads
+		// as processors available
+		private ExecutorService executor = Executors.newFixedThreadPool(Runtime
+				.getRuntime().availableProcessors());
+
+		public ForEach(Iterable<E> elements) {
+			this.elements = elements;
+		}
+
+		/**
+		 * Configure the number of available threads that will be used. Note
+		 * that this configuration has no effect if a custom executor
+		 * {@link ForEach#customExecutor(ExecutorService)} is provided.
+		 * 
+		 * @param threads
+		 *            number of threads to use
+		 * @return a ForEach instance
+		 */
+		public ForEach<E, V> withThreads(int threads) {
+			this.executor = Executors.newFixedThreadPool(threads);
+			return this;
+		}
+
+		/**
+		 * Set a custom executor service
+		 * 
+		 * @param executor
+		 *            ExecutorService to use
+		 * @return the instance of ForEach configured with the new executor
+		 *         service.
+		 */
+		public ForEach<E, V> customExecutor(ExecutorService executor) {
+			this.executor = executor;
+			return this;
+		}
+
+		/**
+		 * Encapsulates the ForEach instance into a Callable that retrieves a
+		 * TaskHandler with the invoked tasks. <br>
+		 * Example: <br>
+		 * 
+		 * <pre>
+		 * Collection&lt;Double&gt; numbers = new Collection&lt;Double&gt;(...);
+		 * Callable&lt;TaskHandler&lt;V&gt;&gt; forEach = new ForEach&lt;Double, String&gt;(numbers)
+		 * 		.prepare(new F&lt;Double, String&gt;() {
+		 * 			String apply(Double e) {
+		 * 				return e.toString();
+		 * 			}
+		 * 		});
+		 * forEach.call().values();
+		 * </pre>
+		 * 
+		 * @param f
+		 * @return
+		 */
+		public Callable<TaskHandler<V>> prepare(final F<E, V> f) {
+			return new Callable<Parallel.TaskHandler<V>>() {
+				public TaskHandler<V> call() throws Exception {
+					return new ForEach<E, V>(elements).apply(f);
+				}
+			};
+		}
+
+		public TaskHandler<V> apply(F<E, V> f) {
+			return new TaskHandler<V>(executor, map(elements, f));
+		}
+
+		private Collection<Callable<V>> map(Iterable<E> elements,
+				final F<E, V> f) {
+			// List of concurrent tasks
+			List<Callable<V>> mappedTasks = new LinkedList<Callable<V>>();
+			// Create a task for each element
+			for (final E element : elements) {
+				mappedTasks.add(new Callable<V>() {
+					public V call() throws Exception {
+						return f.apply(element);
+					}
+				});
+			}
+			return mappedTasks;
+		}
+	}
+
+	/**
+	 * InterruptedExceptions occurred during the execution will be thrown as
+	 * RuntimeExceptions. To handle these interruptions, use new For.Each
+	 * instead of this static method.
+	 * 
+	 * @param elements
+	 * @param task
+	 * @see Each
+	 */
+	public static <A, V> Collection<V> ForEach(Iterable<A> elements,
+			F<A, V> task) {
+		try {
+			return new ForEach<A, V>(elements).apply(task).values();
+		} catch (Exception e) {
+			throw new RuntimeException("ForEach method interrupted. "
+					+ e.getMessage());
+		}
+	}
+
+	/**
+	 * Perform a parallel iteration, similar to a for(i=from;i<to;i++).
+	 * 
+	 * @param from
+	 *            starting index
+	 * @param to
+	 *            upper bound
+	 * @param action
+	 *            the action to perform in each iteration
+	 * @see #ForEach(Iterable, Function)
+	 */
+	public static void For(final long from, final long to,
+			final Action<Long> action) {
+
+		ForEach(new Iterable<Long>() {
+			public Iterator<Long> iterator() {
+				return new Iterator<Long>() {
+					private long current = from;
+
+					public boolean hasNext() {
+						return current < to;
+					}
+
+					public Long next() {
+						return current++;
+					}
+
+					public void remove() {
+						throw new UnsupportedOperationException();
+					}
+				};
+			}
+		}, action);
+	}
+
+}
diff --git a/src/test/java/es/usc/citius/lab/hipster/algorithm/combinatorial/IterativeSetCoverTest.java b/src/test/java/es/usc/citius/lab/hipster/algorithm/combinatorial/IterativeSetCoverTest.java
new file mode 100644
index 0000000..61839b3
--- /dev/null
+++ b/src/test/java/es/usc/citius/lab/hipster/algorithm/combinatorial/IterativeSetCoverTest.java
@@ -0,0 +1,20 @@
+package es.usc.citius.lab.hipster.algorithm.combinatorial;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class IterativeSetCoverTest {
+
+	@Test
+	public void test() {
+		/*
+		Given: Elements of Main Set = {1, 2, 3, 4, 5, 6}
+		Now, consider 4 subsets as follows: Subset 1 = {1, 2}, Subset 2 = {3, 4}, Subset 3 = {5, 6}, Subset 4 = {1, 3, 5}.
+		The Greedy algorithm for the above collection of Subsets gives the Minimum Set Cover as: Minimum Set Cover 
+		contains the Subsets= { 1, 2, 3, 4}. 
+		Test with: http://stackoverflow.com/questions/4287302/find-combinations-of-all-sets-set-cover
+		*/
+	}
+
+}