+ * This class calculates various types of sequence coverage in relation to a collection of observed + * sequences. + *
+ * + * @author Steffen Herbold + * @version 1.0 + */ +public class CoverageCalculatorObserved { + + /** + *+ * Sequences for which the coverage is calculated. + *
+ */ + private final Collection+ * Observed sequences that are baseline for the coverage calculation. + *
+ */ + private final Collection+ * Length of the subsequences in relation to which the covarage is calculated. + *
+ */ + private final int length; + + /** + *+ * All subsequences of {@link #length} of {@link #sequences}. + *
+ */ + private Collection+ * All subsequences of {@link #length} of {@link #observedSequences}. + *
+ */ + private Collection+ * Constructor. Creates a new CoverageCalculatorObserved for given collections of observed + * sequences and generated sequences. + *
+ * + * @param observedSequences + * observed sequences in relation to which the coverage is calculated; must not be + * null + * @param sequences + * sequences for which the coverage is calculated; must not be null + * @param length + * length of the subsequences for which the coverage is analyzed; must be >0 + * @throws IllegalArgumentException + * thrown if observedSequences or sequences is null or length less than or equal to + * 0 + */ + public CoverageCalculatorObserved(Collection+ * Calculates the percentage of subsequences of length k that occur, with reference to those + * that were observed. + *
+ * + * @return coverage percentage + */ + public double getCoverageObserved() { + createSubSeqs(); + Collection+ * Calculates the weight of subsequences of length k that occur, with reference to those that + * were observed. + *
+ * + * @param process + * stochastic process in reference to which the weight is calculated + * @return coverage percentage + */ + + public double getCoverageObservedWeigth(IStochasticProcess process) { + createSubSeqs(); + Map+ * Calculates the percentage of generated subsequences of length k that occur and have not been + * observed, with reference to all generated subsequences. + *
+ * + * @return coverage percentage + */ + public double getNewPercentage() { + createSubSeqs(); + Collection+ * Calculates the percentage of generated subsequences of length k that occur and have not been + * observed, with references to all possible new subsequences. + *
+ * + * @param process + * stochastic process which is used to determine which subsequences are possible + * @return coverage percentage + * @throws IllegalArgumentException + * thrown if process is null + */ + public double getCoveragePossibleNew(IStochasticProcess process) { + if (process == null) { + throw new IllegalArgumentException("process must not be null"); + } + createSubSeqs(); + Collection+ * Calculates the weight of generated subsequences of length k that occur and have not been + * observed, with references to all possible new subsequences. + *
+ * + * @param process + * stochastic process which is used to determine the weights and which subsequences + * are possible + * @return coverage percentage + * @throws IllegalArgumentException + * thrown if process is null + */ + public double getCoveragePossibleNewWeight(IStochasticProcess process) { + if (process == null) { + throw new IllegalArgumentException("process must not be null"); + } + createSubSeqs(); + Collection+ * Returns the number of covered subsequences of length k. + *
+ * + * @return number of covered subsequences + */ + public int getNumObserved() { + createSubSeqs(); + return subSeqsObserved.size(); + } + + /** + *+ * Returns the number of covered subsequences of length k. + *
+ * + * @return number of covered subsequences + */ + public int getNumCovered() { + createSubSeqs(); + return subSeqsGenerated.size(); + } + + public int getNumNew() { + createSubSeqs(); + Collection+ * Helper function that calcuates the subsequences of length k that have been observed and + * generated. + *
+ */ + private void createSubSeqs() { + if (subSeqsObserved == null) { + subSeqsObserved = SequenceTools.containedSubSequences(observedSequences, length); + } + if (subSeqsGenerated == null) { + subSeqsGenerated = SequenceTools.containedSubSequences(sequences, length); + } + } +} Index: /trunk/autoquest-core-coverage/src/main/java/de/ugoe/cs/quest/coverage/CoverageCalculatorProcess.java =================================================================== --- /trunk/autoquest-core-coverage/src/main/java/de/ugoe/cs/quest/coverage/CoverageCalculatorProcess.java (revision 888) +++ /trunk/autoquest-core-coverage/src/main/java/de/ugoe/cs/quest/coverage/CoverageCalculatorProcess.java (revision 888) @@ -0,0 +1,203 @@ +package de.ugoe.cs.quest.coverage; + +import java.util.Collection; +import java.util.List; +import java.util.Map; + +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.usageprofiles.IStochasticProcess; + +/** + *+ * This class calculates various types of sequence coverage in relation to a stochastic process. + *
+ * + * @author Steffen Herbold + * @version 1.0 + */ +public class CoverageCalculatorProcess { + + /** + *+ * Stochastic process that is the foundation for probabilistic coverages and coverages with + * reference to all possible sequences. + *
+ */ + private final IStochasticProcess process; + + /** + *+ * Sequences for which the coverage is calculated. + *
+ */ + private Collection+ * Length of the subsequences in relation to which the coverage is calculated. + *
+ */ + private final int length; + + /** + *+ * All subsequences of {@link #length} of {@link #sequences}. + *
+ */ + private Collection+ * All subsequences of {@link #length} that can be generated by {@link #process}. + *
+ */ + private Collection+ * The probabilities of all subsequences of {@link #length} according to {@link #process}. + *
+ */ + private Map+ * Constructor. Creates a new CoverageCalculatorProcess for a given stochastic process and + * generated sequences. + *
+ * + * @param process + * stochastic process used for coverage calculations; must not be null + * @param sequences + * sequences for which the coverage is calculated; must not be null + * @param length + * length of the subsequences for which the coverage is analyzed; must be >0 + * @throws IllegalArgumentException + * thrown if process or sequences is null or length less than or equal to 0 + */ + public CoverageCalculatorProcess(IStochasticProcess process, + Collection+ * Calculates the percentage of subsequences of length k that occur, including those that cannot + * be generated by {@link #process}. + *
+ * + * @return coverage percentage + */ + public double getCoverageAllNoWeight() { + if (containedSubSeqs == null) { + containedSubSeqs = SequenceTools.containedSubSequences(sequences, length); + } + return ((double) containedSubSeqs.size()) / SequenceTools.numSequences(process, length); + } + + /** + *+ * Calculates the percentage of subsequences of length k that occur and can generated by + * {@link #process}. + *
+ * + * @return coverage percentage + */ + public double getCoveragePossibleNoWeight() { + if (containedSubSeqs == null) { + containedSubSeqs = SequenceTools.containedSubSequences(sequences, length); + } + if (allPossibleSubSeqs == null) { + allPossibleSubSeqs = process.generateSequences(length); + } + return ((double) containedSubSeqs.size()) / allPossibleSubSeqs.size(); + } + + /** + *+ * Calculates the weight of the subsequences that occur with relation to {@link #process}, i.e., + * the mass of the subsequence probability covered by the subsequences. + *
+ * + * @return coverage weight + */ + public double getCoveragePossibleWeight() { + if (containedSubSeqs == null) { + containedSubSeqs = SequenceTools.containedSubSequences(sequences, length); + } + if (allPossibleSubSeqs == null) { + allPossibleSubSeqs = process.generateSequences(length); + } + if (subSeqWeights == null) { + subSeqWeights = SequenceTools.generateWeights(process, allPossibleSubSeqs); + } + double weight = 0.0; + for (List+ * Returns the number of covered subsequences of length k. + *
+ * + * @return number of covered subsequences + */ + public int getNumCovered() { + if (containedSubSeqs == null) { + containedSubSeqs = SequenceTools.containedSubSequences(sequences, length); + } + return containedSubSeqs.size(); + } + + /** + *+ * Returns the number of possible subsequences of length k according to the stochastic process. + *
+ * + * @return number of possible subsequences + */ + public int getNumPossible() { + if (allPossibleSubSeqs == null) { + allPossibleSubSeqs = process.generateSequences(length); + } + return allPossibleSubSeqs.size(); + } + + /** + *+ * Sets a new collection of sequences for which the coverage is analyzed. + *
+ * + * @param newSequences + * new collection of sequences + * @throws IllegalArgumentException + * thrown is newSequences is null + */ + public void setSequences(Collection+ * This class gathers some helper functions to work with sequences. + *
+ * + * @author Steffen Herbold + * @version 1.0 + */ +public class SequenceTools { + + /** + *+ * Private constructor to prevent initializing of the class. + *
+ */ + private SequenceTools() { + + } + + /** + *+ * Calculates the weights for all sequences passed to this function as defined by the stochastic + * process and stores them in a {@link Map}. The weights are normalized, i.e., the sum of all + * weights contained in this map is 1. + *
+ * + * @param process + * process used for weight calculation + * @param sequences + * sequences for which the weights are calculated + * @return {@link Map} of weights + */ + public static Map+ * Calculates the number of all existing sequences of a given length, regardless whether they + * are possible or not. + *
+ * + * @param process + * stochastic process whose symbols are the basis for this calculation + * @param length + * lenght of the sequences + * @return numStates^length + * @throws IllegalArgumentException + * thrown if length less or equal to 0 + */ + public static long numSequences(IStochasticProcess process, int length) { + if (length <= 0) { + throw new IllegalArgumentException("length must be a positive integer"); + } + long result = 0; + if (process != null) { + result = (long) Math.pow(process.getNumSymbols(), length); + } + return result; + } + + /** + *+ * Creates a {@link Set} of all subsequences of a given length that are contained in a sequence + * collection. + *
+ * + * @param sequences + * sequences from which the subsequences are extracted + * @param length + * length of the subsequences + * @return {@link Set} of all subsequences + * @throws IllegalArgumentException + * thrown if length less or equal to 0 + */ + public static Set