Index: trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDgenerateGreedy.java
===================================================================
--- trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDgenerateGreedy.java	(revision 288)
+++ trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDgenerateGreedy.java	(revision 293)
@@ -2,12 +2,18 @@
 
 import java.security.InvalidParameterException;
-import java.util.Collection;
+import java.util.ArrayList;
 import java.util.LinkedHashSet;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import de.ugoe.cs.eventbench.CommandHelpers;
+import de.ugoe.cs.eventbench.coverage.CoverageCalculatorProcess;
+import de.ugoe.cs.eventbench.coverage.SequenceTools;
 import de.ugoe.cs.eventbench.data.Event;
 import de.ugoe.cs.eventbench.data.GlobalDataContainer;
 import de.ugoe.cs.eventbench.models.IStochasticProcess;
+import de.ugoe.cs.util.ArrayTools;
 import de.ugoe.cs.util.console.Command;
 import de.ugoe.cs.util.console.Console;
@@ -21,4 +27,6 @@
  */
 public class CMDgenerateGreedy implements Command {
+	
+	final double eps = 0.000000000001;
 
 	@Override
@@ -28,4 +36,5 @@
 		int minLength;
 		int maxLength;
+		int coverageDepth;
 		float desiredCoverage;
 		try {
@@ -34,5 +43,6 @@
 			minLength = Integer.parseInt((String) parameters.get(2));
 			maxLength = Integer.parseInt((String) parameters.get(3));
-			desiredCoverage = Float.parseFloat((String) parameters.get(4));
+			coverageDepth = Integer.parseInt((String) parameters.get(4));
+			desiredCoverage = Float.parseFloat((String) parameters.get(5));
 		} catch (Exception e) {
 			throw new InvalidParameterException();
@@ -50,22 +60,61 @@
 		}
 		model = (IStochasticProcess) dataObject;
-		Collection<List<? extends Event<?>>> sequences = new LinkedHashSet<List<? extends Event<?>>>();
+		
+		// set up everything
+		List<List<? extends Event<?>>> allSequences = new ArrayList<List<? extends Event<?>>>();
 		for (int length = minLength; length <= maxLength; length++) {
-			sequences.addAll(model.generateValidSequences(length + 2));
+			allSequences.addAll(model.generateValidSequences(length + 2));
 		}
-		Console.traceln("" + sequences.size() + " possible");
+		Console.traceln("" + allSequences.size() + " possible");
 		
+		Set<List<? extends Event<?>>> allSubSeqs = SequenceTools.containedSubSequences(allSequences, coverageDepth);
+		Map<List<? extends Event<?>>, Double> weightMap = SequenceTools.generateWeights(model, allSubSeqs);
+		Set<List<? extends Event<?>>> coveredSubSeqs = new LinkedHashSet<List<? extends Event<?>>>();
 		
-		// TODO implement sequence selection
+		List<Set<List<? extends Event<?>>>> containedSubSeqs = new ArrayList<Set<List<? extends Event<?>>>>(allSequences.size());
+		for( List<? extends Event<?>> sequence : allSequences ) {
+			List<List<? extends Event<?>>>  wrapper = new LinkedList<List<? extends Event<?>>>();
+			wrapper.add(sequence);
+			Set<List<? extends Event<?>>> currentSubSeqs = SequenceTools.containedSubSequences(wrapper, coverageDepth);
+			containedSubSeqs.add(currentSubSeqs);
+		}
 		
-		if (GlobalDataContainer.getInstance().addData(sequencesName, sequences)) {
+		Double[] sequenceGain = new Double[allSequences.size()];
+		List<List<? extends Event<?>>> testSuite = new LinkedList<List<? extends Event<?>>>();
+		CoverageCalculatorProcess coverageCalculator = new CoverageCalculatorProcess(model, testSuite, coverageDepth);
+		double currentCoverage = 0.0d;
+		
+		// Build test suite
+		while( currentCoverage<desiredCoverage ) {
+			for( int i=0 ; i<allSequences.size() ; i++ ) {
+				double gain = 0.0d;
+				for( List<? extends Event<?>> subSeq : containedSubSeqs.get(i) ) {
+					if( !coveredSubSeqs.contains(subSeq) ) {
+						gain += weightMap.get(subSeq);
+					}
+				}
+				sequenceGain[i] = gain;
+			}
+			int maxIndex = ArrayTools.findMax(sequenceGain);
+			if( sequenceGain[maxIndex] <= 0.0+eps ) {
+				Console.traceln("No gain anymore! Desired coverage cannot be satisfied!");
+				break;
+			}
+			testSuite.add(allSequences.get(maxIndex));
+			coveredSubSeqs.addAll(containedSubSeqs.get(maxIndex));
+			coverageCalculator.setSequences(testSuite);
+			currentCoverage = coverageCalculator.getCoveragePossibleWeight();
+		}
+		
+		if (GlobalDataContainer.getInstance().addData(sequencesName, testSuite)) {
 			CommandHelpers.dataOverwritten(sequencesName);
 		}
-		Console.println("" + sequences.size() + " sequences generated");
+		Console.println("" + testSuite.size() + " sequences generated");
+		Console.println("" + currentCoverage + " coverage achieved");
 	}
 
 	@Override
 	public void help() {
-		Console.println("generateGreedy <modelname> <sequencesName> <minLength> <maxLength> <desiredCoverage>");
+		Console.println("generateGreedy <modelname> <sequencesName> <minLength> <maxLength> <coverageDepth> <desiredCoverage>");
 	}