Index: bidspace/src/main/java/geniusweb/bidspace/BidsWithUtility.java
===================================================================
--- bidspace/src/main/java/geniusweb/bidspace/BidsWithUtility.java	(revision 2)
+++ bidspace/src/main/java/geniusweb/bidspace/BidsWithUtility.java	(revision 2)
@@ -0,0 +1,60 @@
+package geniusweb.bidspace;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+import geniusweb.issuevalue.Bid;
+import geniusweb.profile.utilityspace.LinearAdditiveUtilitySpace;
+import tudelft.utilities.immutablelist.AbstractImmutableList;
+
+/**
+ * Object containing a subset of all bids, that have utility within given range.
+ */
+public class BidsWithUtility extends AbstractImmutableList<Bid> {
+
+	private final List<Bid> collectedbids;
+
+	/**
+	 * Create Bids with utility within given bounds.
+	 * 
+	 * @param space the {@link LinearAdditiveUtilitySpace} to search
+	 * @param min   the minimum required utility
+	 * @param max   the maximum required utility
+	 */
+	public BidsWithUtility(LinearAdditiveUtilitySpace space, BigDecimal min, BigDecimal max) {
+		this.collectedbids = new ArrayList<Bid>(getBids(space, min, max));
+	}
+
+	/**
+	 * Brute force hack for this time. Maybe we can construct this in a lazy way.
+	 * 
+	 * @param space
+	 * @param min
+	 * @param max
+	 * @return
+	 */
+	private List<Bid> getBids(LinearAdditiveUtilitySpace space, BigDecimal min, BigDecimal max) {
+		List<Bid> goodbids = new LinkedList<Bid>();
+		for (Bid bid : new AllBidsList(space.getDomain())) {
+			BigDecimal util = space.getUtility(bid);
+			if (util.compareTo(min) >= 0 && util.compareTo(max) <= 0) {
+				goodbids.add(bid);
+			}
+		}
+		return goodbids;
+	}
+
+	@Override
+	public Bid get(BigInteger index) {
+		return collectedbids.get(index.intValue());
+	}
+
+	@Override
+	public BigInteger size() {
+		return BigInteger.valueOf(collectedbids.size());
+	}
+
+}
Index: bidspace/src/main/java/geniusweb/bidspace/PartialSpaceFromUtility.java
===================================================================
--- bidspace/src/main/java/geniusweb/bidspace/PartialSpaceFromUtility.java	(revision 2)
+++ bidspace/src/main/java/geniusweb/bidspace/PartialSpaceFromUtility.java	(revision 2)
@@ -0,0 +1,91 @@
+package geniusweb.bidspace;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import geniusweb.issuevalue.Bid;
+import geniusweb.profile.DefaultPartialOrdering;
+import geniusweb.profile.PartialOrdering;
+import geniusweb.profile.utilityspace.UtilitySpace;
+import tudelft.utilities.immutablelist.ListWithRemove;
+import tudelft.utilities.immutablelist.Tuple;
+import tudelft.utilities.immutablelist.Tuples;
+
+/**
+ * Simple demo converting a {@link UtilitySpace} into a {@link PartialOrdering}.
+ * Notice, a UtilitySpace IS a PartialOrdering, but a special one that is in
+ * fact a full ordering. This converter makes it a space that really has all
+ * info removed except for a few basic "isBetter" informations.
+ */
+public class PartialSpaceFromUtility extends DefaultPartialOrdering {
+	public PartialSpaceFromUtility(UtilitySpace space, int nRankings) {
+		super(space.getName() + "_" + nRankings, space.getDomain(), space.getReservationBid(),
+				pickBetter(space, nRankings));
+	}
+
+	/**
+	 * Pick subset of static isbetter rankings. Notice, ShuffledList currently can't
+	 * handle really large lists which also limits this. This has to be fixed.
+	 * 
+	 * @param space     the space to sample from
+	 * @param nRankings the number of rankings to be placed in the PartialOrdering.
+	 * @return a subset creating a partial profile of the geiven UtilitySpace
+	 */
+	private static Map<Bid, Set<Bid>> pickBetter(UtilitySpace space, int nRankings) {
+		Map<Bid, Set<Bid>> eqOrBetter = new HashMap<>();
+
+		AllBidsList allbids = new AllBidsList(space.getDomain());
+		ListWithRemove<Tuple<Bid, Bid>> available = new ListWithRemove<>(new Tuples<Bid, Bid>(allbids, allbids));
+		for (int n = 0; n < nRankings; n++) {
+			BigInteger sel = rnd(available.size());
+			Tuple<Bid, Bid> tuple = available.get(sel);
+			Bid bid1 = tuple.get1();
+			Bid bid2 = tuple.get2();
+			switch (space.getUtility(bid1).compareTo(space.getUtility(bid2))) {
+			case -1: // bid1 is worse
+				add(eqOrBetter, bid2, bid1);
+				break;
+			case 0:
+				add(eqOrBetter, bid2, bid1);
+				add(eqOrBetter, bid1, bid2);
+				break;
+			case 1:// bid1 is better
+				add(eqOrBetter, bid1, bid2);
+				break;
+			}
+			available = available.remove(sel);
+		}
+		return eqOrBetter;
+	}
+
+	/**
+	 * 
+	 * @param eqOrBetter map to be extended with (key=bid1, value=bid2)
+	 * @param bid1       the key to add a value to
+	 * @param bid2       the value to be added
+	 */
+	private static void add(Map<Bid, Set<Bid>> eqOrBetter, Bid bid1, Bid bid2) {
+		Set<Bid> set = eqOrBetter.get(bid1);
+		if (set == null) {
+			set = new HashSet<Bid>();
+		}
+		set.add(bid2);
+		eqOrBetter.put(bid1, set);
+	}
+
+	/**
+	 * Bit simplistic way to generate random in [0,n>. Simplistic because the mod()
+	 * operator that we use causes bias in the random numbers.
+	 * 
+	 * @param n the maximum value for the random number
+	 * @return random in [0,n>
+	 * 
+	 */
+	private static final BigInteger rnd(BigInteger n) {
+		return new BigInteger(n.bitLength(), new SecureRandom()).mod(n);
+	}
+}
