Ignore:
Timestamp:
09/28/11 03:03:13 (13 years ago)
Author:
sherbold
Message:
  • greatly improved type checking and consistency of type checking for objects checked out of the GlobalDataContainer?
Location:
trunk/EventBenchConsole/src/de/ugoe/cs/eventbench
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/AbstractTrainCommand.java

    r203 r209  
    55import java.util.List; 
    66 
     7import de.ugoe.cs.eventbench.SequenceInstanceOf; 
    78import de.ugoe.cs.eventbench.data.Event; 
    89import de.ugoe.cs.eventbench.data.GlobalDataContainer; 
    … …  
    6970                } 
    7071 
    71                 Collection<List<Event<?>>> sequences = null; 
    7272                Object dataObject = GlobalDataContainer.getInstance().getData( 
    7373                                sequencesName); 
    … …  
    7777                        return; 
    7878                } 
    79                 try { 
    80                         sequences = (Collection<List<Event<?>>>) dataObject; 
    81                 } catch (ClassCastException e) { 
     79                if (!SequenceInstanceOf.isCollectionOfSequences(dataObject)) { 
    8280                        Console.println("Object " + sequencesName 
    8381                                        + "not of type Collection<List<Event<?>>>."); 
    8482                        return; 
    8583                } 
    86                 /* TODO implement better type check 
    87                 if (sequences.size() == 0 || !(sequences.get(0).get(0) instanceof Event) ) { 
    88                         Console.println("Object " + sequencesName 
    89                                         + "not of type Collection<List<Event<?>>>."); 
    90                         return; 
    91                 } 
    92                 */ 
     84                Collection<List<Event<?>>> sequences = (Collection<List<Event<?>>>) dataObject; 
    9385 
    9486                TrieBasedModel model = createModel(); 
    9587                model.train(sequences); 
    96                 if (GlobalDataContainer.getInstance().addData(modelname, 
    97                                 model)) { 
    98                         Console.traceln("Old data \"" + modelname 
    99                                         + "\" overwritten"); 
     88                if (GlobalDataContainer.getInstance().addData(modelname, model)) { 
     89                        Console.traceln("Old data \"" + modelname + "\" overwritten"); 
    10090                } 
    101                  
     91 
    10292        } 
    10393 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDcalcCoverage.java

    r171 r209  
    55import java.util.List; 
    66 
     7import de.ugoe.cs.eventbench.SequenceInstanceOf; 
    78import de.ugoe.cs.eventbench.coverage.CoverageCalculatorObserved; 
    89import de.ugoe.cs.eventbench.coverage.CoverageCalculatorProcess; 
    … …  
    6869                        return; 
    6970                } 
    70                 if (!(dataObjectObserved instanceof Collection<?>)) { 
    71                         // weak instance check! 
    72                         Console.printerrln("Object " + observedName + " not a Collection!"); 
     71                if (!SequenceInstanceOf.isCollectionOfSequences(dataObjectObserved)) { 
     72                        Console.printerrln("Object " + observedName 
     73                                        + " of type Collection<List<Event<?>>>!"); 
    7374                        return; 
    7475                } 
    … …  
    9899                                Console.println("Sequences " + sequenceName 
    99100                                                + " not found in storage."); 
    100                         } else if (!(dataObjectSequences instanceof Collection<?>)) { 
    101                                 // cannot really perform type check at runtime! this is an 
    102                                 // approximative substitute 
     101                                return; 
     102                        } else if (!SequenceInstanceOf 
     103                                        .isCollectionOfSequences(dataObjectSequences)) { 
    103104                                Console.printerrln("Object " + sequenceName 
    104                                                 + "not of type Collection<?>!"); 
     105                                                + "not of type Collection<List<Event<?>!"); 
    105106                                return; 
    106107                        } 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDcalcEntropy.java

    r171 r209  
    11package de.ugoe.cs.eventbench.commands; 
     2 
    23import java.security.InvalidParameterException; 
    34import java.util.List; 
    … …  
    1819public class CMDcalcEntropy implements Command { 
    1920 
    20         /* (non-Javadoc) 
     21        /* 
     22         * (non-Javadoc) 
     23         *  
    2124         * @see de.ugoe.cs.util.console.Command#help() 
    2225         */ 
    … …  
    2629        } 
    2730 
    28         /* (non-Javadoc) 
     31        /* 
     32         * (non-Javadoc) 
     33         *  
    2934         * @see de.ugoe.cs.util.console.Command#run(java.util.List) 
    3035         */ 
    … …  
    3742                        throw new InvalidParameterException(); 
    3843                } 
    39                  
    40                 FirstOrderMarkovModel model = null;  
    41                 Object dataObject = GlobalDataContainer.getInstance().getData(modelname); 
    42                 if( dataObject==null ) { 
     44 
     45                FirstOrderMarkovModel model = null; 
     46                Object dataObject = GlobalDataContainer.getInstance() 
     47                                .getData(modelname); 
     48                if (dataObject == null) { 
    4349                        Console.println("Model " + modelname + "not found in storage."); 
     50                        return; 
    4451                } 
    45                 else if( !(dataObject instanceof FirstOrderMarkovModel) ) { 
    46                         Console.println("Object " + modelname + " is not a first-order Markov model!"); 
    47                 } else { 
    48                         model = (FirstOrderMarkovModel) dataObject; 
    49                         double entropy = model.calcEntropy(); 
    50                         if( !Double.isNaN(entropy) ) { 
    51                                 Console.println("entropy: " + entropy); 
    52                         } 
     52                if (!(dataObject instanceof FirstOrderMarkovModel)) { 
     53                        Console.println("Object " + modelname 
     54                                        + " is not a first-order Markov model!"); 
     55                        return; 
     56                } 
     57                model = (FirstOrderMarkovModel) dataObject; 
     58                double entropy = model.calcEntropy(); 
     59                if (!Double.isNaN(entropy)) { 
     60                        Console.println("entropy: " + entropy); 
    5361                } 
    5462        } 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDgenerateFixedLengthSequences.java

    r171 r209  
    6060                if (dataObject == null) { 
    6161                        Console.println("Model " + modelname + " not found in storage."); 
     62                        return; 
    6263                } else if (!(dataObject instanceof IStochasticProcess)) { 
    6364                        Console.println("Object " + modelname + " not of type MarkovModel!"); 
    64                 } else { 
    65                         model = (IStochasticProcess) dataObject; 
    66                         Collection<List<? extends Event<?>>> sequences = new LinkedHashSet<List<? extends Event<?>>>(); 
    67                         for (int length = minLength; length <= maxLength; length++) { 
    68                                 sequences.addAll(model.generateValidSequences(length + 2)); 
     65                        return; 
     66                } 
     67                model = (IStochasticProcess) dataObject; 
     68                Collection<List<? extends Event<?>>> sequences = new LinkedHashSet<List<? extends Event<?>>>(); 
     69                for (int length = minLength; length <= maxLength; length++) { 
     70                        sequences.addAll(model.generateValidSequences(length + 2)); 
     71                } 
     72                Console.traceln("" + sequences.size() + " possible"); 
     73                if (!all && numSequences < sequences.size()) { 
     74                        List<Double> probabilities = new ArrayList<Double>(sequences.size()); 
     75                        double probSum = 0.0; 
     76                        for (List<? extends Event<?>> sequence : sequences) { 
     77                                double prob = model.getProbability(sequence); 
     78                                probabilities.add(prob); 
     79                                probSum += prob; 
    6980                        } 
    70                         Console.traceln("" + sequences.size() + " possible"); 
    71                         if (!all && numSequences < sequences.size()) { 
    72                                 List<Double> probabilities = new ArrayList<Double>( 
    73                                                 sequences.size()); 
    74                                 double probSum = 0.0; 
    75                                 for (List<? extends Event<?>> sequence : sequences) { 
    76                                         double prob = model.getProbability(sequence); 
    77                                         probabilities.add(prob); 
    78                                         probSum += prob; 
     81                        Set<Integer> drawnSequences = new HashSet<Integer>(numSequences); 
     82                        Random r = new Random(); 
     83                        while (drawnSequences.size() < numSequences) { 
     84                                double randVal = r.nextDouble() * probSum; 
     85                                double sum = 0.0d; 
     86                                int index = -1; 
     87                                while (sum < randVal) { 
     88                                        index++; 
     89                                        double currentProb = probabilities.get(index); 
     90                                        sum += currentProb; 
    7991                                } 
    80                                 Set<Integer> drawnSequences = new HashSet<Integer>(numSequences); 
    81                                 Random r = new Random(); 
    82                                 while (drawnSequences.size() < numSequences) { 
    83                                         double randVal = r.nextDouble() * probSum; 
    84                                         double sum = 0.0d; 
    85                                         int index = -1; 
    86                                         while (sum < randVal) { 
    87                                                 index++; 
    88                                                 double currentProb = probabilities.get(index); 
    89                                                 sum += currentProb; 
    90                                         } 
    91                                         if (!drawnSequences.contains(index)) { 
    92                                                 drawnSequences.add(index); 
    93                                                 probSum -= probabilities.get(index); 
    94                                                 probabilities.set(index, 0.0d); 
    95                                         } 
     92                                if (!drawnSequences.contains(index)) { 
     93                                        drawnSequences.add(index); 
     94                                        probSum -= probabilities.get(index); 
     95                                        probabilities.set(index, 0.0d); 
    9696                                } 
    97                                 Collection<List<? extends Event<?>>> retainedSequences = new LinkedList<List<? extends Event<?>>>(); 
    98                                 int index = 0; 
    99                                 for (List<? extends Event<?>> sequence : sequences) { 
    100                                         if (drawnSequences.contains(index)) { 
    101                                                 retainedSequences.add(sequence); 
    102                                         } 
    103                                         index++; 
     97                        } 
     98                        Collection<List<? extends Event<?>>> retainedSequences = new LinkedList<List<? extends Event<?>>>(); 
     99                        int index = 0; 
     100                        for (List<? extends Event<?>> sequence : sequences) { 
     101                                if (drawnSequences.contains(index)) { 
     102                                        retainedSequences.add(sequence); 
    104103                                } 
    105                                 sequences = retainedSequences; 
     104                                index++; 
    106105                        } 
    107                         if (GlobalDataContainer.getInstance().addData(sequencesName, 
    108                                         sequences)) { 
    109                                 Console.traceln("Old data \"" + sequencesName 
    110                                                 + "\" overwritten"); 
    111                         } 
    112                         Console.println("" + sequences.size() + " sequences generated"); 
     106                        sequences = retainedSequences; 
    113107                } 
     108                if (GlobalDataContainer.getInstance().addData(sequencesName, sequences)) { 
     109                        Console.traceln("Old data \"" + sequencesName + "\" overwritten"); 
     110                } 
     111                Console.println("" + sequences.size() + " sequences generated"); 
    114112        } 
    115113 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDgenerateRandomReplay.java

    r203 r209  
    5959                if (dataObject == null) { 
    6060                        Console.println("Model " + modelname + " not found in storage."); 
    61                 } else if (!(dataObject instanceof IStochasticProcess)) { 
     61                        return; 
     62                } 
     63                if (!(dataObject instanceof IStochasticProcess)) { 
    6264                        Console.println("Object " + modelname + " not of type MarkovModel!"); 
    63                 } else { 
    64                         model = (IStochasticProcess) dataObject; 
    65                         Collection<List<ReplayableEvent<?>>> sequences = new LinkedList<List<ReplayableEvent<?>>>(); 
    66                         try { 
    67                                 for (int i = 0; i < numSessions; i++) { 
    68                                         sequences.add((List<ReplayableEvent<?>>) model 
    69                                                         .randomSequence()); 
    70                                 } 
    71                         } catch (ClassCastException e) { 
    72                                 Console.println("Modeled events don't support replay."); 
     65                        return; 
     66                } 
     67                model = (IStochasticProcess) dataObject; 
     68                Collection<List<ReplayableEvent<?>>> sequences = new LinkedList<List<ReplayableEvent<?>>>(); 
     69                try { 
     70                        for (int i = 0; i < numSessions; i++) { 
     71                                sequences 
     72                                                .add((List<ReplayableEvent<?>>) model.randomSequence()); 
    7373                        } 
    74                         ReplayGenerator generator = new ReplayGenerator(); 
    75                         generator.createLogfileMultipleSessions(sequences, filename); 
     74                } catch (ClassCastException e) { 
     75                        Console.println("Modeled events don't support replay."); 
    7676                } 
     77                ReplayGenerator generator = new ReplayGenerator(); 
     78                generator.createLogfileMultipleSessions(sequences, filename); 
    7779        } 
    7880 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDgenerateRandomSequences.java

    r171 r209  
    1313 
    1414/** 
    15  * <p>Command to generate random sessions.</p> 
     15 * <p> 
     16 * Command to generate random sessions. 
     17 * </p> 
     18 *  
    1619 * @author Steffen Herbold 
    1720 * @version 1.0 
    … …  
    1922public class CMDgenerateRandomSequences implements Command { 
    2023 
    21         /* (non-Javadoc) 
     24        /* 
     25         * (non-Javadoc) 
     26         *  
    2227         * @see de.ugoe.cs.util.console.Command#run(java.util.List) 
    2328         */ 
    … …  
    3439                        sequencesName = (String) parameters.get(1); 
    3540                        numSessions = Integer.parseInt((String) parameters.get(2)); 
    36                         maxIter = numSessions*10; 
    37                         if( parameters.size()>=4 ) { 
     41                        maxIter = numSessions * 10; 
     42                        if (parameters.size() >= 4) { 
    3843                                maxIter = Long.parseLong((String) parameters.get(3)); 
    3944                        } 
    40                         if( parameters.size()>=5 ) { 
     45                        if (parameters.size() >= 5) { 
    4146                                minLength = Integer.parseInt((String) parameters.get(4)); 
    4247                        } 
    43                         if( parameters.size()>=6 ) { 
     48                        if (parameters.size() >= 6) { 
    4449                                maxLength = Integer.parseInt((String) parameters.get(5)); 
    4550                        } 
    46                 } 
    47                 catch (Exception e) { 
     51                } catch (Exception e) { 
    4852                        throw new InvalidParameterException(); 
    4953                } 
    50                  
    51                 IStochasticProcess model = null;  
    52                 Object dataObject = GlobalDataContainer.getInstance().getData(modelname); 
    53                 if( dataObject==null ) { 
     54 
     55                IStochasticProcess model = null; 
     56                Object dataObject = GlobalDataContainer.getInstance() 
     57                                .getData(modelname); 
     58                if (dataObject == null) { 
    5459                        Console.println("Model " + modelname + " not found in storage."); 
     60                        return; 
    5561                } 
    56                 else if( !(dataObject instanceof IStochasticProcess) ) { 
     62                if (!(dataObject instanceof IStochasticProcess)) { 
    5763                        Console.println("Object " + modelname + " not of type MarkovModel!"); 
    58                 } else { 
    59                         model = (IStochasticProcess) dataObject; 
    60                         Set<List<? extends Event<?>>> sequences = new HashSet<List<? extends Event<?>>>(numSessions); 
    61                         long numIterations = 0; 
    62                         while( sequences.size()<numSessions && numIterations<maxIter ) { 
    63                                 List<? extends Event<?>> generatedSequence = model.randomSequence(); 
    64                                 if( generatedSequence.size()>=minLength && generatedSequence.size()<=maxLength ) { 
    65                                         sequences.add(generatedSequence); 
    66                                 } 
    67                                 numIterations++; 
     64                        return; 
     65                } 
     66                model = (IStochasticProcess) dataObject; 
     67                Set<List<? extends Event<?>>> sequences = new HashSet<List<? extends Event<?>>>( 
     68                                numSessions); 
     69                long numIterations = 0; 
     70                while (sequences.size() < numSessions && numIterations < maxIter) { 
     71                        List<? extends Event<?>> generatedSequence = model.randomSequence(); 
     72                        if (generatedSequence.size() >= minLength 
     73                                        && generatedSequence.size() <= maxLength) { 
     74                                sequences.add(generatedSequence); 
    6875                        } 
    69                         if( sequences.size() < numSessions ) { 
    70                                 Console.println("Only " + sequences.size() + " unique sessions generated after " + maxIter + " iterations"); 
    71                         } 
    72                         if( GlobalDataContainer.getInstance().addData(sequencesName, sequences) ) { 
    73                                 Console.traceln("Old data \"" + sequencesName + "\" overwritten"); 
    74                         } 
     76                        numIterations++; 
     77                } 
     78                if (sequences.size() < numSessions) { 
     79                        Console.println("Only " + sequences.size() 
     80                                        + " unique sessions generated after " + maxIter 
     81                                        + " iterations"); 
     82                } 
     83                if (GlobalDataContainer.getInstance().addData(sequencesName, sequences)) { 
     84                        Console.traceln("Old data \"" + sequencesName + "\" overwritten"); 
    7585                } 
    7686        } 
    7787 
    78         /* (non-Javadoc) 
     88        /* 
     89         * (non-Javadoc) 
     90         *  
    7991         * @see de.ugoe.cs.util.console.Command#help() 
    8092         */ 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDgenerateReplayfile.java

    r203 r209  
    66 
    77import de.ugoe.cs.eventbench.ReplayGenerator; 
    8 import de.ugoe.cs.eventbench.data.Event; 
     8import de.ugoe.cs.eventbench.SequenceInstanceOf; 
    99import de.ugoe.cs.eventbench.data.GlobalDataContainer; 
    1010import de.ugoe.cs.eventbench.data.ReplayableEvent; 
    … …  
    1313 
    1414/** 
    15  * <p>Command to create a replay file from stored sessions.</p> 
     15 * <p> 
     16 * Command to create a replay file from stored sessions. 
     17 * </p> 
     18 *  
    1619 * @author Steffen Herbold 
    1720 * @version 1.0 
    … …  
    1922public class CMDgenerateReplayfile implements Command { 
    2023 
    21         /* (non-Javadoc) 
     24        /* 
     25         * (non-Javadoc) 
     26         *  
    2227         * @see de.ugoe.cs.util.console.Command#help() 
    2328         */ 
    2429        @Override 
    2530        public void help() { 
    26                 Console.println("Usage: generateReplayfile <filename> {<sequences>}");           
     31                Console.println("Usage: generateReplayfile <filename> {<sequences>}"); 
    2732        } 
    2833 
    29         /* (non-Javadoc) 
     34        /* 
     35         * (non-Javadoc) 
     36         *  
    3037         * @see de.ugoe.cs.util.console.Command#run(java.util.List) 
    3138         */ 
    … …  
    3340        @Override 
    3441        public void run(List<Object> parameters) { 
    35                 if( parameters.size() < 1 ) { 
     42                if (parameters.size() < 1) { 
    3643                        throw new InvalidParameterException(); 
    3744                } 
    3845                String filename = (String) parameters.get(0); 
    3946                String sequencesName = "sequences"; 
    40                 if( parameters.size()==2 ) { 
     47                if (parameters.size() == 2) { 
    4148                        sequencesName = (String) parameters.get(1); 
    4249                } 
    43                  
     50 
    4451                Collection<List<ReplayableEvent<?>>> sequences = null; 
    45                 Object dataObject = GlobalDataContainer.getInstance().getData(sequencesName); 
    46                          
    47                 try { 
    48                         sequences = (Collection<List<ReplayableEvent<?>>>) dataObject; 
    49                         ReplayGenerator generator = new ReplayGenerator(); 
    50                         if( sequences!=null && sequences.size()>0 && sequences.iterator().next().get(0) instanceof Event ) { 
    51                                 generator.createLogfileMultipleSessions(sequences, filename); 
    52                         } else { 
    53                                 Console.printerrln("Loaded data not are not sequences!"); 
    54                                 if( sequencesName.equals("sequences") ) {  
    55                                         Console.traceln("Illegal use of \"sequences\" parameter in the GlobalDataContainer."); 
    56                                         Console.traceln("The parameter should always be of type Collection<List<Event>>!"); 
    57                                 } 
    58                         } 
     52                Object dataObject = GlobalDataContainer.getInstance().getData( 
     53                                sequencesName); 
     54                if (dataObject == null) { 
     55                        Console.println("Object " + sequencesName 
     56                                        + " not found in storage."); 
     57                        return; 
    5958                } 
    60                 catch(ClassCastException e) { 
    61                         Console.printerrln("Sequences not found"); 
     59                if (!SequenceInstanceOf.isCollectionOfSequences(dataObject)) { 
     60                        Console.println("Object " + sequencesName 
     61                                        + "not of type Collection<List<Event<?>>>."); 
     62                        return; 
    6263                } 
    63                  
     64 
     65                sequences = (Collection<List<ReplayableEvent<?>>>) dataObject; 
     66                ReplayGenerator generator = new ReplayGenerator(); 
     67                generator.createLogfileMultipleSessions(sequences, filename); 
    6468        } 
    6569 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDlistSymbols.java

    r179 r209  
    4444                if (dataObject == null) { 
    4545                        Console.println("Model " + modelname + "not found in storage."); 
    46                 } else if (!(dataObject instanceof IStochasticProcess)) { 
     46                        return; 
     47                } 
     48                if (!(dataObject instanceof IStochasticProcess)) { 
    4749                        Console.println("Object " + modelname 
    4850                                        + " is not a stochastic process!"); 
    49                 } else { 
    50                         model = (IStochasticProcess) dataObject; 
    51                         String[] stateStrings = model.getSymbolStrings(); 
    52                         if (sort) { 
    53                                 Arrays.sort(stateStrings); 
    54                         } 
    55                         for (String stateString : stateStrings) { 
    56                                 Console.println(stateString); 
    57                         } 
     51                        return; 
     52                } 
     53                model = (IStochasticProcess) dataObject; 
     54                String[] stateStrings = model.getSymbolStrings(); 
     55                if (sort) { 
     56                        Arrays.sort(stateStrings); 
     57                } 
     58                for (String stateString : stateStrings) { 
     59                        Console.println(stateString); 
    5860                } 
    5961        } 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDload.java

    r171 r209  
    4343                        in.close(); 
    4444                } catch (IOException ex) { 
    45                         ex.printStackTrace(); 
     45                        Console.printStacktrace(ex); 
    4646                } catch (ClassNotFoundException ex) { 
    47                         ex.printStackTrace(); 
     47                        Console.printStacktrace(ex); 
    4848                } 
    4949        } 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDloadObject.java

    r171 r209  
    4747                        in.close(); 
    4848                } catch (IOException ex) { 
    49                         ex.printStackTrace(); 
     49                        Console.printStacktrace(ex); 
    5050                } catch (ClassNotFoundException ex) { 
    51                         ex.printStackTrace(); 
     51                        Console.printStacktrace(ex); 
    5252                } 
    5353                if (GlobalDataContainer.getInstance().addData(objectName, data)) { 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDprintDot.java

    r171 r209  
    4949                if (dataObject == null) { 
    5050                        Console.println("Model " + modelname + "not found in storage."); 
    51                 } else if (!(dataObject instanceof IDotCompatible)) { 
     51                        return; 
     52                } 
     53                if (!(dataObject instanceof IDotCompatible)) { 
    5254                        Console.println("Object " + modelname 
    5355                                        + " does not implement IDotCompatible!"); 
    54                 } else { 
    55                         model = (IDotCompatible) dataObject; 
    56                         Console.println(model.getDotRepresentation()); 
     56                        return; 
    5757                } 
     58 
     59                model = (IDotCompatible) dataObject; 
     60                Console.println(model.getDotRepresentation()); 
    5861        } 
    5962 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDprintRandomSession.java

    r171 r209  
    4949                if (dataObject == null) { 
    5050                        Console.println("Model " + modelname + " not found in storage."); 
    51                 } else if (!(dataObject instanceof IStochasticProcess)) { 
     51                        return; 
     52                } 
     53                if (!(dataObject instanceof IStochasticProcess)) { 
    5254                        Console.println("Object " + modelname + " not of type MarkovModel!"); 
    53                 } else { 
    54                         model = (IStochasticProcess) dataObject; 
    55                         for (Event<?> event : model.randomSequence()) { 
    56                                 Console.println(event.toString()); 
    57                         } 
     55                        return; 
     56                } 
     57 
     58                model = (IStochasticProcess) dataObject; 
     59                for (Event<?> event : model.randomSequence()) { 
     60                        Console.println(event.toString()); 
    5861                } 
    5962        } 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDprintTrieDot.java

    r171 r209  
    5050                if (dataObject == null) { 
    5151                        Console.println("Model " + modelname + "not found in storage."); 
    52                 } else if (!(dataObject instanceof TrieBasedModel)) { 
     52                        return; 
     53                } 
     54                if (!(dataObject instanceof TrieBasedModel)) { 
    5355                        Console.println("Object " + modelname + " is not a TrieBasedModel!"); 
    54                 } else { 
    55                         model = (TrieBasedModel) dataObject; 
    56                         Console.println(model.getTrieDotRepresentation()); 
     56                        return; 
    5757                } 
     58 
     59                model = (TrieBasedModel) dataObject; 
     60                Console.println(model.getTrieDotRepresentation()); 
    5861        } 
    5962 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDsave.java

    r171 r209  
    4343                        out.close(); 
    4444                } catch (IOException ex) { 
    45                         ex.printStackTrace(); 
     45                        Console.printStacktrace(ex); 
    4646                } 
    4747        } 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDsaveObject.java

    r171 r209  
    5252                        out.close(); 
    5353                } catch (IOException ex) { 
    54                         ex.printStackTrace(); 
     54                        Console.printStacktrace(ex); 
    5555                } 
    5656        } 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDsequenceStatistics.java

    r203 r209  
    77import java.util.TreeMap; 
    88 
     9import de.ugoe.cs.eventbench.SequenceInstanceOf; 
    910import de.ugoe.cs.eventbench.data.Event; 
    1011import de.ugoe.cs.eventbench.data.GlobalDataContainer; 
    … …  
    3940                Object dataObject = GlobalDataContainer.getInstance().getData( 
    4041                                sequencesName); 
     42                if (dataObject == null) { 
     43                        Console.println("Object " + sequencesName 
     44                                        + " not found in storage."); 
     45                        return; 
     46                } 
     47                if (!SequenceInstanceOf.isCollectionOfSequences(dataObject)) { 
     48                        Console.println("Object " + sequencesName 
     49                                        + "not of type Collection<List<Event<?>>>."); 
     50                        return; 
     51                } 
    4152 
    42                 try { 
    43                         sequences = (Collection<List<Event<?>>>) dataObject; 
    44                         Console.traceln("Number of Sequences: " + sequences.size()); 
    45                         SortedMap<Integer, Integer> lengthMap = new TreeMap<Integer, Integer>(); 
    46                         for (List<Event<?>> sequence : sequences) { 
    47                                 Integer currentSize = sequence.size(); 
    48                                 if (lengthMap.containsKey(currentSize)) { 
    49                                         lengthMap.put(currentSize, lengthMap.get(currentSize) + 1); 
    50                                 } else { 
    51                                         lengthMap.put(currentSize, 1); 
    52                                 } 
     53                sequences = (Collection<List<Event<?>>>) dataObject; 
     54                Console.traceln("Number of Sequences: " + sequences.size()); 
     55                SortedMap<Integer, Integer> lengthMap = new TreeMap<Integer, Integer>(); 
     56                for (List<Event<?>> sequence : sequences) { 
     57                        Integer currentSize = sequence.size(); 
     58                        if (lengthMap.containsKey(currentSize)) { 
     59                                lengthMap.put(currentSize, lengthMap.get(currentSize) + 1); 
     60                        } else { 
     61                                lengthMap.put(currentSize, 1); 
    5362                        } 
    54                         for (Entry<Integer, Integer> entry : lengthMap.entrySet()) { 
    55                                 Console.traceln("Of length " + entry.getKey() + ": " 
    56                                                 + entry.getValue()); 
    57                         } 
    58  
    59                 } catch (ClassCastException e) { 
    60                         Console.println("Sequences not found"); 
     63                } 
     64                for (Entry<Integer, Integer> entry : lengthMap.entrySet()) { 
     65                        Console.traceln("Of length " + entry.getKey() + ": " 
     66                                        + entry.getValue()); 
    6167                } 
    6268        } 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDshowMarkovModel.java

    r171 r209  
    6565                                .getData(modelname); 
    6666                if (dataObject == null) { 
    67                         Console.printerrln("No model with name " + modelname + "found"); 
    68                 } else { 
    69                         FirstOrderMarkovModel mm = (FirstOrderMarkovModel) dataObject; 
     67                        Console.println("Object " + modelname + " not found in storage."); 
     68                        return; 
     69                } 
     70                if (!(dataObject instanceof FirstOrderMarkovModel)) { 
     71                        Console.println("Object " + modelname 
     72                                        + "not of type FirstOrderMarkovModel."); 
     73                        return; 
     74                } 
     75                FirstOrderMarkovModel mm = (FirstOrderMarkovModel) dataObject; 
    7076 
    71                         Graph<String, MarkovEdge> graph = mm.getGraph(); 
    72                         Layout<String, MarkovEdge> layout = new ISOMLayout<String, MarkovEdge>( 
    73                                         graph); 
    74                         layout.setSize(new Dimension(1000, 800)); // sets the initial size 
    75                                                                                                                 // of the space 
    76                         // The BasicVisualizationServer<V,E> is parameterized by the edge 
    77                         // types 
    78                         BasicVisualizationServer<String, MarkovEdge> vv = new BasicVisualizationServer<String, MarkovEdge>( 
    79                                         layout); 
    80                         vv.setPreferredSize(new Dimension(1100, 850)); // Sets the viewing 
    81                                                                                                                         // area size 
     77                Graph<String, MarkovEdge> graph = mm.getGraph(); 
     78                Layout<String, MarkovEdge> layout = new ISOMLayout<String, MarkovEdge>( 
     79                                graph); 
     80                layout.setSize(new Dimension(1000, 800)); // sets the initial size 
     81                                                                                                        // of the space 
     82                // The BasicVisualizationServer<V,E> is parameterized by the edge 
     83                // types 
     84                BasicVisualizationServer<String, MarkovEdge> vv = new BasicVisualizationServer<String, MarkovEdge>( 
     85                                layout); 
     86                vv.setPreferredSize(new Dimension(1100, 850)); // Sets the viewing 
     87                                                                                                                // area size 
    8288 
    83                         if (showNodeNames) { 
    84                                 final Rectangle rect = new Rectangle(240, 20); 
     89                if (showNodeNames) { 
     90                        final Rectangle rect = new Rectangle(240, 20); 
    8591 
    86                                 Transformer<String, Shape> vertexShapeTransformer = new Transformer<String, Shape>() { 
    87                                         public Shape transform(String s) { 
    88                                                 return rect; 
    89                                         } 
    90                                 }; 
    91                                 vv.getRenderer().getVertexLabelRenderer() 
    92                                                 .setPosition(Position.CNTR); 
    93                                 vv.getRenderContext().setVertexShapeTransformer( 
    94                                                 vertexShapeTransformer); 
    95                                 vv.getRenderContext().setVertexLabelTransformer( 
    96                                                 new ToStringLabeller<String>()); 
    97                         } 
     92                        Transformer<String, Shape> vertexShapeTransformer = new Transformer<String, Shape>() { 
     93                                public Shape transform(String s) { 
     94                                        return rect; 
     95                                } 
     96                        }; 
     97                        vv.getRenderer().getVertexLabelRenderer() 
     98                                        .setPosition(Position.CNTR); 
     99                        vv.getRenderContext().setVertexShapeTransformer( 
     100                                        vertexShapeTransformer); 
     101                        vv.getRenderContext().setVertexLabelTransformer( 
     102                                        new ToStringLabeller<String>()); 
     103                } 
    98104 
    99                         vv.getRenderContext().setEdgeLabelTransformer( 
    100                                         new ToStringLabeller<MarkovEdge>()); 
     105                vv.getRenderContext().setEdgeLabelTransformer( 
     106                                new ToStringLabeller<MarkovEdge>()); 
    101107 
    102                         JFrame frame = new JFrame("Markov Model"); 
    103                         frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 
    104                         frame.getContentPane().add(vv); 
    105                         frame.pack(); 
    106                         frame.setVisible(true); 
    107                 } 
     108                JFrame frame = new JFrame("Markov Model"); 
     109                frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 
     110                frame.getContentPane().add(vv); 
     111                frame.pack(); 
     112                frame.setVisible(true); 
    108113        } 
    109114} 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDshowTrie.java

    r171 r209  
    6262                                .getData(modelname); 
    6363                if (dataObject == null) { 
    64                         Console.printerrln("No model with name " + modelname + "found"); 
    65                 } else { 
    66                         TrieBasedModel model = (TrieBasedModel) dataObject; 
    67                         Tree<TrieVertex, Edge> graph = model.getTrieGraph(); 
    68                         Layout<TrieVertex, Edge> layout = new TreeLayout<TrieVertex, Edge>( 
    69                                         graph, 60); 
    70                         // The BasicVisualizationServer<V,E> is parameterized by the edge 
    71                         // types 
    72                         BasicVisualizationServer<TrieVertex, Edge> vv = new BasicVisualizationServer<TrieVertex, Edge>( 
    73                                         layout); 
    74                         vv.setPreferredSize(new Dimension(1100, 850)); // Sets the viewing 
    75                                                                                                                         // area size 
     64                        Console.printerrln("Object " + modelname + " not found in storage."); 
     65                        return; 
     66                } 
     67                if (!(dataObject instanceof TrieBasedModel)) { 
     68                        Console.printerr("Object " + modelname 
     69                                        + " not of type TrieBasedModel."); 
     70                } 
     71                TrieBasedModel model = (TrieBasedModel) dataObject; 
     72                Tree<TrieVertex, Edge> graph = model.getTrieGraph(); 
     73                Layout<TrieVertex, Edge> layout = new TreeLayout<TrieVertex, Edge>( 
     74                                graph, 60); 
     75                // The BasicVisualizationServer<V,E> is parameterized by the edge 
     76                // types 
     77                BasicVisualizationServer<TrieVertex, Edge> vv = new BasicVisualizationServer<TrieVertex, Edge>( 
     78                                layout); 
     79                vv.setPreferredSize(new Dimension(1100, 850)); // Sets the viewing 
     80                                                                                                                // area size 
    7681 
    77                         final Rectangle rect = new Rectangle(40, 20); 
     82                final Rectangle rect = new Rectangle(40, 20); 
    7883 
    79                         Transformer<TrieVertex, Shape> vertexShapeTransformer = new Transformer<TrieVertex, Shape>() { 
    80                                 public Shape transform(TrieVertex s) { 
    81                                         return rect; 
    82                                 } 
    83                         }; 
    84                         vv.getRenderer().getVertexLabelRenderer() 
    85                                         .setPosition(Position.CNTR); 
    86                         vv.getRenderContext().setVertexShapeTransformer( 
    87                                         vertexShapeTransformer); 
    88                         vv.getRenderContext().setVertexLabelTransformer( 
    89                                         new ToStringLabeller<TrieVertex>()); 
     84                Transformer<TrieVertex, Shape> vertexShapeTransformer = new Transformer<TrieVertex, Shape>() { 
     85                        public Shape transform(TrieVertex s) { 
     86                                return rect; 
     87                        } 
     88                }; 
     89                vv.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR); 
     90                vv.getRenderContext().setVertexShapeTransformer(vertexShapeTransformer); 
     91                vv.getRenderContext().setVertexLabelTransformer( 
     92                                new ToStringLabeller<TrieVertex>()); 
    9093 
    91                         JFrame frame = new JFrame("Trie"); 
    92                         frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 
    93                         frame.getContentPane().add(vv); 
    94                         frame.pack(); 
    95                         frame.setVisible(true); 
    96                 } 
     94                JFrame frame = new JFrame("Trie"); 
     95                frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 
     96                frame.getContentPane().add(vv); 
     97                frame.pack(); 
     98                frame.setVisible(true); 
    9799        } 
    98100 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/commands/CMDupdateModel.java

    r203 r209  
    55import java.util.List; 
    66 
     7import de.ugoe.cs.eventbench.SequenceInstanceOf; 
    78import de.ugoe.cs.eventbench.data.Event; 
    89import de.ugoe.cs.eventbench.data.GlobalDataContainer; 
    … …  
    3940                } 
    4041 
    41                 Collection<List<Event<?>>> sequences = null; 
    4242                Object dataObject = GlobalDataContainer.getInstance().getData( 
    4343                                sequencesName); 
    … …  
    4747                        return; 
    4848                } 
    49                 try { 
    50                         sequences = (Collection<List<Event<?>>>) dataObject; 
    51                 } catch (ClassCastException e) { 
    52                         Console.println("Object " + sequencesName 
    53                                         + "not of type Collection<List<Event<?>>>."); 
    54                 } 
    55                 if (sequences.size() == 0 
    56                                 || !(sequences.iterator().next().get(0) instanceof Event)) { 
     49                if (!SequenceInstanceOf.isCollectionOfSequences(dataObject)) { 
    5750                        Console.println("Object " + sequencesName 
    5851                                        + "not of type Collection<List<Event<?>>>."); 
    5952                        return; 
    6053                } 
     54                Collection<List<Event<?>>> sequences = (Collection<List<Event<?>>>) dataObject; 
    6155 
    6256                dataObject = GlobalDataContainer.getInstance().getData(modelname); 
    6357                if (dataObject == null) { 
    64                         Console.println("Model " + modelname + " not found in storage."); 
     58                        Console.println("Object " + modelname + " not found in storage."); 
    6559                        return; 
    6660                } 
    6761                if (!(dataObject instanceof TrieBasedModel)) { 
    6862                        Console.println("Object " + modelname 
    69                                         + " not of type TrieBasedModel!"); 
     63                                        + " not of type TrieBasedModel"); 
    7064                        return; 
    7165                } 
     66 
    7267                TrieBasedModel model = (TrieBasedModel) dataObject; 
    7368                model.update(sequences); 

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/data/GlobalDataContainer.java

    r191 r209  
    88import java.util.HashMap; 
    99import java.util.LinkedList; 
    10 import java.util.List; 
    1110import java.util.Map; 
    1211import java.util.Map.Entry; 
    1312 
     13import de.ugoe.cs.eventbench.SequenceInstanceOf; 
    1414import de.ugoe.cs.eventbench.models.IStochasticProcess; 
    1515 
    … …  
    188188                Collection<String> allSequencesNames = new LinkedList<String>(); 
    189189                for (Entry<String, Object> entry : dataObjects.entrySet()) { 
    190                         if (entry.getValue() instanceof Collection<?>) { 
    191                                 Object listObj = ((Collection<?>) entry.getValue()).iterator() 
    192                                                 .next(); 
    193                                 if (listObj instanceof List<?>) { 
    194                                         if (((List<?>) listObj).iterator().next() instanceof Event<?>) { 
    195                                                 allSequencesNames.add(entry.getKey()); 
    196                                         } 
    197                                 } 
     190                        if( SequenceInstanceOf.isCollectionOfSequences(entry.getValue())) { 
     191                                allSequencesNames.add(entry.getKey()); 
    198192                        } 
    199193                } 
Note: See TracChangeset for help on using the changeset viewer.