source: trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDgenerateHybrid.java

package de.ugoe.cs.eventbench.commands;

import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

import de.ugoe.cs.eventbench.CommandHelpers;
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.console.Command;
import de.ugoe.cs.util.console.Console;

/**
 * <p>
 * Command to generate sequences of a given length.
 * </p>
 * 
 * @author Steffen Herbold
 * @version 1.0
 */
public class CMDgenerateHybrid implements Command {

        /*
         * (non-Javadoc)
         * 
         * @see de.ugoe.cs.util.console.Command#run(java.util.List)
         */
        @Override
        public void run(List<Object> parameters) {
                String modelname;
                String sequencesName;
                int length;
                int maxLengthAll;
                int numSequences;
                boolean validEnd = true;
                try {
                        modelname = (String) parameters.get(0);
                        sequencesName = (String) parameters.get(1);
                        length = Integer.parseInt((String) parameters.get(2));
                        maxLengthAll = Integer.parseInt((String) parameters.get(3));
                        numSequences = Integer.parseInt((String) parameters.get(4));
                        if (parameters.size() >= 6) {
                                validEnd = Boolean.parseBoolean((String) parameters.get(5));
                        }
                } catch (Exception e) {
                        throw new InvalidParameterException();
                }

                if (length <= maxLengthAll) {
                        // indirectly call command generateFixedLengthSequences
                        List<Object> parameters2 = new LinkedList<Object>();
                        parameters2.add(modelname);
                        parameters2.add(sequencesName);
                        parameters2.add(Integer.toString(length));
                        parameters2.add(Integer.toString(length));
                        parameters2.add(Boolean.toString(false));
                        parameters2.add(Integer.toString(numSequences));
                        parameters2.add(Boolean.toString(validEnd));
                        CMDgenerateFixedLengthSequences cmd = new CMDgenerateFixedLengthSequences();
                        cmd.run(parameters2);
                        return;
                }

                IStochasticProcess model = null;
                Object dataObject = GlobalDataContainer.getInstance()
                                .getData(modelname);
                if (dataObject == null) {
                        CommandHelpers.objectNotFoundMessage(modelname);
                        return;
                } else if (!(dataObject instanceof IStochasticProcess)) {
                        CommandHelpers.objectNotType(modelname, "IStochasticProcess");
                        return;
                }
                model = (IStochasticProcess) dataObject;
                Collection<List<? extends Event<?>>> sequences = new LinkedHashSet<List<? extends Event<?>>>();

                List<List<? extends Event<?>>> seqsTmp = new ArrayList<List<? extends Event<?>>>(
                                model.generateSequences(maxLengthAll + 1, true));

                Console.traceln("" + seqsTmp.size() + " of length " + maxLengthAll
                                + " possible");
                List<Double> probabilities = new ArrayList<Double>(seqsTmp.size());
                double probSum = 0.0;
                for (List<? extends Event<?>> sequence : seqsTmp) {
                        double prob = model.getProbability(sequence);
                        probabilities.add(prob);
                        probSum += prob;
                }

                Random r = new Random();
                int j = 0;
                while (sequences.size() < numSequences && j <= numSequences * 100) {
                        j++;
                        double randVal = r.nextDouble() * probSum;
                        double sum = 0.0d;
                        int index = -1;
                        while (sum < randVal) {
                                index++;
                                double currentProb = probabilities.get(index);
                                sum += currentProb;
                        }
                        List<? extends Event<?>> seqTmp = seqsTmp.get(index);
                        if (!Event.ENDEVENT.equals(seqTmp.get(seqTmp.size() - 1))) {
                                List<? extends Event<?>> sequence;
                                if (validEnd) {
                                        sequence = finishSequence(seqTmp, model, length + 2,
                                                        validEnd);
                                        if( sequence!= null && sequence.size()!=length+2 ) {
                                                sequence = null;
                                        }
                                } else {
                                        sequence = finishSequence(seqTmp, model, length + 1,
                                                        validEnd);
                                        if( sequence!= null && sequence.size()!=length+1 ) {
                                                sequence = null;
                                        }
                                }
                                if( sequence!=null ) {
                                        sequences.add(sequence);
                                }
                        }
                }
                if (GlobalDataContainer.getInstance().addData(sequencesName, sequences)) {
                        CommandHelpers.dataOverwritten(sequencesName);
                }
                Console.println("" + sequences.size() + " sequences generated");
        }

        public List<? extends Event<?>> finishSequence(
                        List<? extends Event<?>> sequence, IStochasticProcess model,
                        int maxLength, boolean validEnd) {
                Random r = new Random();
                boolean endFound = false;
                List<Event<?>> sequenceCopy = new LinkedList<Event<?>>(sequence);
                final int maxIter = 30000;
                int iter = 0;
                while (!endFound && iter<maxIter) {
                        iter++;
                        sequenceCopy = new LinkedList<Event<?>>(sequence);
                        while (!endFound && sequenceCopy.size() <= maxLength) {
                                double randVal = r.nextDouble();
                                double probSum = 0.0;
                                for (Event<?> symbol : model.getEvents()) {
                                        probSum += model.getProbability(sequenceCopy, symbol);
                                        if (probSum >= randVal) {
                                                if (!(Event.STARTEVENT.equals(symbol) || (!validEnd && Event.ENDEVENT.equals(symbol)))) {
                                                        // only add the symbol the sequence if it is not
                                                        // START
                                                        // or END
                                                        sequenceCopy.add(symbol);
                                                }
                                                endFound = Event.ENDEVENT.equals(symbol)
                                                                || (!validEnd && sequenceCopy.size() == maxLength);
                                                break;
                                        }
                                }
                        }
                }
                if( iter==maxIter ) {
                        return null;
                }
                return sequenceCopy;
        }

        /*
         * (non-Javadoc)
         * 
         * @see de.ugoe.cs.util.console.Command#help()
         */
        @Override
        public void help() {
                Console.println("Usage: generateHybrid <modelname> <sequencesName> <lenght> <maxlengthAll> <numSequences> {<validEnd>}");
        }

}