+ * 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 InvalidParameterException + * 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 InvalidParameterException + * thrown if process is null + */ + public double getCoveragePossibleNew(IStochasticProcess process) { + if (process == null) { + throw new InvalidParameterException("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 InvalidParameterException + * thrown if process is null + */ + public double getCoveragePossibleNewWeight(IStochasticProcess process) { + if (process == null) { + throw new InvalidParameterException("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/quest-core-coverage/src/main/java/de/ugoe/cs/quest/coverage/CoverageCalculatorProcess.java =================================================================== --- trunk/quest-core-coverage/src/main/java/de/ugoe/cs/quest/coverage/CoverageCalculatorProcess.java (revision 518) +++ trunk/quest-core-coverage/src/main/java/de/ugoe/cs/quest/coverage/CoverageCalculatorProcess.java (revision 518) @@ -0,0 +1,218 @@ +package de.ugoe.cs.quest.coverage; + +import java.security.InvalidParameterException; +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 InvalidParameterException + * 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> subSeq : containedSubSeqs) { + Double curWeight = subSeqWeights.get(subSeq); + if( curWeight!=null ) { + weight += curWeight; + } + } + return weight; + } + + /** + *+ * 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 InvalidParameterException + * 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 InvalidParameterException + * thrown if length less or equal to 0 + */ + public static long numSequences(IStochasticProcess process, int length) { + if (length <= 0) { + throw new InvalidParameterException( + "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 InvalidParameterException + * thrown if length less or equal to 0 + */ + public static Set