Changeset 123 for trunk/EventBenchCore

Timestamp:

07/14/11 12:04:30 (13 years ago)

Author:

sherbold

Message:

+ added class de.ugoe.cs.eventbench.coverage.SequenceTools? and refactored static helper methods from de.ugoe.cs.eventbench.coverage.CoverageCalculater? into the new class
+ added class de.ugoe.cs.eventbench.coverage.CoverageCalculatorObserved? for calculation of coverage criteria with reference to the observed sequences

Location:

trunk/EventBenchCore/src/de/ugoe/cs/eventbench/coverage

Files:

• CoverageCalculator.java (modified) (10 diffs)
• CoverageCalculatorObserved.java (added)
• SequenceTools.java (added)

trunk/EventBenchCore/src/de/ugoe/cs/eventbench/coverage/CoverageCalculator.java

@@ -3 +3 @@
 import java.security.InvalidParameterException;
 import java.util.Collection;
-import java.util.LinkedHashMap;
-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.data.Event;
@@ -15 +11 @@
 /**
  * <p>
- * This class calculates various types of sequence coverage.
+ * This class calculates various types of sequence coverage in relation to a
+ * stochastic process.
  * </p>
  * 
@@ -76 +73 @@
          * 
          * @param process
-         *            stochastic process used for coverage calculations; must not be null
+         *            stochastic process used for coverage calculations; must not be
+         *            null
          * @param sequences
          *            sequences for which the coverage is calculated; must not be
@@ -86 +84 @@
         public CoverageCalculator(IStochasticProcess process,
                         Collection<List<? extends Event<?>>> sequences, int length) {
-                if( process==null ) {
+                if (process == null) {
                         throw new InvalidParameterException("process must not be null");
                 }
-                if( sequences==null ) {
+                if (sequences == null) {
                         throw new InvalidParameterException("sequences must not be null");
                 }
-                if( length<=0 ) {
-                        throw new InvalidParameterException("length must be >0; actual value: " + length);
+                if (length <= 0) {
+                        throw new InvalidParameterException(
+                                        "length must be >0; actual value: " + length);
                 }
                 this.process = process;
@@ -102 +101 @@
         /**
          * <p>
-         * Calculates the percentage of subsequences of length k that exist occur,
+         * Calculates the percentage of subsequences of length k that occur,
          * including those that cannot be generated by {@link #process}.
          * </p>
@@ -110 +109 @@
         public double getCoverageAllNoWeight() {
                 if (containedSubSeqs == null) {
-                        containedSubSeqs = containedSubSequences(sequences, length);
+                        containedSubSeqs = SequenceTools.containedSubSequences(sequences,
+                                        length);
                 }
                 return ((double) containedSubSeqs.size())
-                                / numSequences(process, length);
+                                / SequenceTools.numSequences(process, length);
         }
 
@@ -126 +126 @@
         public double getCoveragePossibleNoWeight() {
                 if (containedSubSeqs == null) {
-                        containedSubSeqs = containedSubSequences(sequences, length);
+                        containedSubSeqs = SequenceTools.containedSubSequences(sequences,
+                                        length);
                 }
                 if (allPossibleSubSeqs == null) {
@@ -145 +146 @@
         public double getCoveragePossibleWeight() {
                 if (containedSubSeqs == null) {
-                        containedSubSeqs = containedSubSequences(sequences, length);
+                        containedSubSeqs = SequenceTools.containedSubSequences(sequences,
+                                        length);
                 }
                 if (allPossibleSubSeqs == null) {
@@ -151 +153 @@
                 }
                 if (subSeqWeights == null) {
-                        subSeqWeights = generateWeights(process, allPossibleSubSeqs);
+                        subSeqWeights = SequenceTools.generateWeights(process,
+                                        allPossibleSubSeqs);
                 }
                 double weight = 0.0;
@@ -160 +163 @@
         }
 
-        /**
-         * <p>
-         * Calculates the weights for all sequences passed to this function as
-         * defined by the stochastic process and stores them in a {@link Map}.
-         * </p>
-         * 
-         * @param process
-         *            process used for weight calculation
-         * @param sequences
-         *            sequences for which the weights are calculated
-         * @return {@link Map} of weights
-         */
-        private static Map<List<? extends Event<?>>, Double> generateWeights(
-                        IStochasticProcess process,
-                        Collection<List<? extends Event<?>>> sequences) {
-                Map<List<? extends Event<?>>, Double> subSeqWeights = new LinkedHashMap<List<? extends Event<?>>, Double>();
-                double sum = 0.0;
-                for (List<? extends Event<?>> sequence : sequences) {
-                        double prob = process.getProbability(sequence);
-                        subSeqWeights.put(sequence, prob);
-                        sum += prob;
-                }
-                if (sum < 1.0) {
-                        for (Map.Entry<List<? extends Event<?>>, Double> entry : subSeqWeights
-                                        .entrySet()) {
-                                entry.setValue(entry.getValue() / sum);
-                        }
-                }
-                return subSeqWeights;
-        }
-
-        /**
-         * <p>
-         * Calculates the number of all existing sequences of a given length,
-         * regardless whether they are possible or not.
-         * </p>
-         * 
-         * @param process
-         *            stochastic process whose symbols are the basis for this
-         *            calculation
-         * @param length
-         *            lenght of the sequences
-         * @return numStates^length
-         */
-        private static long numSequences(IStochasticProcess process, int length) {
-                return (long) Math.pow(process.getNumStates(), length);
-        }
-
-        /**
-         * <p>
-         * Creates a {@link Set} of all subsequences of a given length that are
-         * contained in a sequence collection.
-         * </p>
-         * 
-         * @param sequences
-         *            sequences from which the subsequences are extracted
-         * @param length
-         *            length of the subsequences
-         * @return {@link Set} of all subsequences
-         */
-        private static Set<List<? extends Event<?>>> containedSubSequences(
-                        Collection<List<? extends Event<?>>> sequences, int length) {
-                Set<List<? extends Event<?>>> containedSubSeqs = new LinkedHashSet<List<? extends Event<?>>>();
-                for (List<? extends Event<?>> sequence : sequences) {
-                        List<Event<?>> subSeq = new LinkedList<Event<?>>();
-                        boolean minLengthReached = false;
-                        for (Event<?> event : sequence) {
-                                subSeq.add(event);
-                                if (!minLengthReached) {
-                                        if (subSeq.size() == length) {
-                                                minLengthReached = true;
-                                        }
-                                } else {
-                                        subSeq.remove(0);
-                                }
-                                if (minLengthReached) {
-                                        if (!containedSubSeqs.contains(subSeq)) {
-                                                containedSubSeqs.add(new LinkedList<Event<?>>(subSeq));
-                                        }
-                                }
-                        }
-                }
-                return containedSubSeqs;
-        }
-
 }