Examples of statechum.ProgressIndicator

statechum.ProgressIndicator

    { 
      runners[i]=new ErlangRuntime();processNames[i]=""+currentNumber++;runners[i].startErlang(processNames[i], 0); 
    }
    Random rnd = new Random(0);
    final int testNumber = 1000;
    ProgressIndicator progress = new ProgressIndicator("Random erlang tests", testNumber);
    for(int cnt=0;cnt < testNumber;++cnt)
    {
      int runnerNumber = rnd.nextInt(runners.length);
      ErlangRuntime r = runners[runnerNumber];
      if (rnd.nextInt(100) > 1)
      {
        int numA = rnd.nextInt(10000)-5000, numB=rnd.nextInt(10000)-5000;
        ErlangRunner rn = new ErlangRunner(r.traceRunnerNode);rn.forceReady();// only using default instances
        OtpErlangTuple response = (OtpErlangTuple)rn.call(new OtpErlangObject[]{new OtpErlangAtom("echo"),
            new OtpErlangList(new OtpErlangObject[]{ new OtpErlangAtom(dataHead), new OtpErlangInt(numA), new OtpErlangInt(numB),new OtpErlangAtom(dataC)})},
            0);


        Assert.assertEquals(dataHead,((OtpErlangAtom)response.elementAt(0)).atomValue());
        Assert.assertEquals(processNames[runnerNumber],((OtpErlangAtom)response.elementAt(1)).atomValue());
        OtpErlangObject [] list = ((OtpErlangList)response.elementAt(2)).elements();
        Assert.assertEquals(3, list.length);
        Assert.assertEquals(numA,((OtpErlangLong)list[0]).intValue());
        Assert.assertEquals(numB,((OtpErlangLong)list[1]).intValue());
        Assert.assertEquals(dataC,((OtpErlangAtom)list[2]).atomValue());
      }
      else 
      {
        r.killErlang();processNames[runnerNumber]=""+currentNumber++;runners[runnerNumber].startErlang(processNames[runnerNumber], 0);
      }
      progress.next();
    }
    for(int i=0;i<runners.length;++i) runners[i].killErlang();
    Assert.assertTrue(currentNumber > runners.length+10);
  }

View Full Code Here

    { 
      runners[i]=new ErlangRunner();processNames[i]=""+currentNumber++;runners[i].startErlang(processNames[i], 0); 
    }
    Random rnd = new Random(0);
    final int testNumber = 1000;
    ProgressIndicator progress = new ProgressIndicator("Random erlang tests", testNumber);
    for(int cnt=0;cnt < testNumber;++cnt)
    {
      int runnerNumber = rnd.nextInt(runners.length);
      ErlangRunner r = runners[runnerNumber];
      if (rnd.nextInt(100) > 1)
      {
        int numA = rnd.nextInt(10000)-5000, numB=rnd.nextInt(10000)-5000;
        OtpErlangTuple response = (OtpErlangTuple)r.call(new OtpErlangObject[]{new OtpErlangAtom("echo"),
            new OtpErlangList(new OtpErlangObject[]{ new OtpErlangAtom(dataHead), new OtpErlangInt(numA), new OtpErlangInt(numB),new OtpErlangAtom(dataC)})},
            0);


        Assert.assertEquals(dataHead,((OtpErlangAtom)response.elementAt(0)).atomValue());
        Assert.assertEquals(processNames[runnerNumber],((OtpErlangAtom)response.elementAt(1)).atomValue());
        OtpErlangObject [] list = ((OtpErlangList)response.elementAt(2)).elements();
        Assert.assertEquals(3, list.length);
        Assert.assertEquals(numA,((OtpErlangLong)list[0]).intValue());
        Assert.assertEquals(numB,((OtpErlangLong)list[1]).intValue());
        Assert.assertEquals(dataC,((OtpErlangAtom)list[2]).atomValue());
      }
      else 
      {
        r.killErlang();processNames[runnerNumber]=""+currentNumber++;runners[runnerNumber].startErlang(processNames[runnerNumber], 0);
      }
      progress.next();
    }
    for(int i=0;i<runners.length;++i) runners[i].killErlang();
    Assert.assertTrue(currentNumber > runners.length+10);
  }

View Full Code Here

      try
      {
        switch(phase)
        {
        case RUN_STANDALONE:
          ProgressIndicator progress = new ProgressIndicator(new Date()+" evaluating "+(taskCounter-taskCounterFromPreviousSubExperiment)+" tasks for "+experimentName, taskCounter-taskCounterFromPreviousSubExperiment);
          for(int count=taskCounterFromPreviousSubExperiment;count < taskCounter;++count)
          {
            RESULT result = runner.take().get();// this will throw an exception if any of the tasks failed.
            if (result == null)
              throw new IllegalArgumentException("experiment "+taskToRun+" did not complete or returned null");
            handlerForExperimentResults.processSubResult(result,this);plotAllGraphs(nameToGraph.values(),count);
            progress.next();
          }
          plotAllGraphs(nameToGraph.values(),-1);
          break;
        case COUNT_TASKS:
          break;

View Full Code Here

      int alphabet = states/2;
      
      MachineGenerator mg = new MachineGenerator(states, 40, states/10);
      int mutationsPerStage = (states/2) / 2;
      //System.out.print("\n"+states+": ");
      ProgressIndicator progress = new ProgressIndicator(""+states, mutationStages*experimentsPerMutationCategory);
      for(int mutationStage = 0;mutationStage<mutationStages;mutationStage++)
      {
        for(int experiment=0;experiment<experimentsPerMutationCategory;experiment++)
        {
          ExperimentResult outcome = new ExperimentResult();
          while(!outcome.experimentValid)
          {
            int mutations = mutationsPerStage * (mutationStage+1);
            LearnerGraphND origGraph = mg.nextMachine(alphabet, experiment,config);
            GraphMutator<List<CmpVertex>,LearnerGraphNDCachedData> mutator = new GraphMutator<List<CmpVertex>,LearnerGraphNDCachedData>(origGraph,r);
            mutator.mutate(mutations);
            LearnerGraphND origAfterRenaming = new LearnerGraphND(origGraph.config);
            Map<CmpVertex,CmpVertex> origToNew = copyStatesAndTransitions(origGraph,origAfterRenaming);
            LearnerGraphND mutated = (LearnerGraphND)mutator.getMutated();
            Set<Transition> appliedMutations = new HashSet<Transition>();
            for(Transition tr:mutator.getDiff())
            {
              CmpVertex renamedFrom = origToNew.get(tr.getFrom());if (renamedFrom == null) renamedFrom = tr.getFrom();
              CmpVertex renamedTo = origToNew.get(tr.getTo());if (renamedTo == null) renamedTo = tr.getTo();
              appliedMutations.add(new Transition(renamedFrom,renamedTo,tr.getLabel()));
            }
            
            final double perfectLowToHigh=0.7,perfectThreshold=0.5;
            
            // These experiments are only run for the maximal number of states
            if (graphComplexity == graphComplexityMax-1)
            {
              for(double k:new double[]{0,.2,.4,.6,.8,.95})
              {
                config.setAttenuationK(k);
                config.setGdKeyPairThreshold(0.5);
                config.setGdLowToHighRatio(perfectLowToHigh);
                config.setGdPropagateDet(false);// this is to ensure that if we removed a transition 0 from to a state and then added one from that state to a different one, det-propagation will not force the two very different states into a key-pair relation. 
                linearDiff(origAfterRenaming,mutated, appliedMutations,outcome);
                
                gr_Diff_k.add(k, outcome.getValue(DOUBLE_V.OBTAINED_TO_EXPECTED));
                
              }


              for(double threshold:new double[]{0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.95})
              {
                config.setGdKeyPairThreshold(threshold);
                config.setGdLowToHighRatio(perfectLowToHigh);
                config.setGdPropagateDet(false);// this is to ensure that if we removed a transition 0 from to a state and then added one from that state to a different one, det-propagation will not force the two very different states into a key-pair relation. 
                linearDiff(origAfterRenaming,mutated, appliedMutations,outcome);
                
                gr_Diff_threshold.add(threshold, outcome.getValue(DOUBLE_V.OBTAINED_TO_EXPECTED));
              }


              for(double lowtohigh:new double[]{0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.95})
              {
                config.setGdKeyPairThreshold(perfectThreshold);
                config.setGdLowToHighRatio(lowtohigh);
                config.setGdPropagateDet(false);// this is to ensure that if we removed a transition 0 from to a state and then added one from that state to a different one, det-propagation will not force the two very different states into a key-pair relation. 
                linearDiff(origAfterRenaming,mutated, appliedMutations,outcome);
                
                gr_Diff_lowtohigh.add(lowtohigh, outcome.getValue(DOUBLE_V.OBTAINED_TO_EXPECTED));
              }
              
              
              for(int i=0;i<pairThreshold.length;++i)
                for(double ratio:lowToHigh)
                {
                  config.setGdKeyPairThreshold(pairThreshold[i]);
                  config.setGdLowToHighRatio(ratio);
                  config.setGdPropagateDet(false);// this is to ensure that if we removed a transition 0 from to a state and then added one from that state to a different one, det-propagation will not force the two very different states into a key-pair relation. 
                  linearDiff(origAfterRenaming,mutated, appliedMutations,outcome);
                  
                  gr_Diff_thresholdslowhigh.add(new Pair<Double,Double>(ratio,pairThreshold[i]), outcome.getValue(DOUBLE_V.OBTAINED_TO_EXPECTED));
                }
            }
            config.setAttenuationK(0.5);
            config.setGdKeyPairThreshold(perfectThreshold);
            config.setGdLowToHighRatio(perfectLowToHigh);
            config.setGdPropagateDet(false);// this is to ensure that if we removed a transition 0 from to a state and then added one from that state to a different one, det-propagation will not force the two very different states into a key-pair relation. 
            linearDiff(origAfterRenaming,mutated, appliedMutations,outcome);
            
            if (!skip)
            {
              LearnerGraph fromDet = null, toDet = null;
              try {
                fromDet = mergeAndDeterminize(origAfterRenaming);
                toDet = mergeAndDeterminize(mutated);
              } catch (IncompatibleStatesException e) {
                Helper.throwUnchecked("failed to build a deterministic graph from a nondet one", e);
              }
              languageDiff(fromDet,toDet,states, graphComplexity,outcome);
            }
            outcome.experimentValid = true;
            progress.next();
            gr_Diff_States.add(states, outcome.getValue(DOUBLE_V.OBTAINED_TO_EXPECTED));
            gr_W_States.add(states,outcome.getValue(DOUBLE_V.ACCURACY_W));
            Pair<Integer,Integer> mutations_states = new Pair<Integer,Integer>(mutationStage+1,states);
            Pair<Integer,Integer> states_mutations = new Pair<Integer,Integer>(states,mutationStage+1);
            gr_DiffGD_StatesLevel.add(mutations_states, outcome.getValue(DOUBLE_V.OBTAINED_TO_EXPECTED));

View Full Code Here

  
  private ErlangModule(Configuration config) throws IOException {
    final File f = config.getErlangSourceFile();
    name = ErlangRunner.getName(f, ERL.MOD);
    sourceFolder = f.getParentFile();
    ProgressIndicator progress = new ProgressIndicator(name, 7);
    // launch Erlang by calling a test method.
    ErlangRunner.getRunner().call(
        new OtpErlangObject[] { new OtpErlangAtom("echo2Tuple"),
            new OtpErlangAtom("aaa") }, "echo2Tuple");
    progress.next();// 1


    // Compile and typecheck the module...
    ErlangRunner.compileErl(f, ErlangRunner.getRunner());
    progress.next();// 2
    sigs = new TreeMap<String, FuncSignature>();ignoredFunctions = new TreeSet<String>();ignoredBehaviours = new TreeSet<String>();


    File pltFile = new File(ErlangRunner.getName(f, ERL.PLT));


    // Almost the same arguments for dialyzer and typer, the first argument
    // determines which of the two to run.
    OtpErlangObject otpArgs[] = new OtpErlangObject[] {
        null, // either Dialyzer or typer


        new OtpErlangList(new OtpErlangObject[] { new OtpErlangString(
            ErlangRunner.getName(f, ERL.BEAM)) }),
        new OtpErlangString(ErlangRunner.getName(f, ERL.PLT)),
        new OtpErlangList(new OtpErlangObject[] { new OtpErlangString(
            ErlangRunner.getName(f, ERL.ERL)) }),
        new OtpErlangAtom("types") };


    if (!pltFile.canRead() || f.lastModified() > pltFile.lastModified()) {// rebuild the PLT file since the source was modified or the plt file does not exist
      pltFile.delete();
      otpArgs[0] = new OtpErlangAtom("dialyzer");
      ErlangRunner.getRunner().call(otpArgs, "Could not run dialyzer");
    }
    progress.next();// 3


    // Typer always has to be run
    otpArgs[0] = new OtpErlangAtom("typer");
    OtpErlangTuple response = null;
    try
    {
      response = ErlangRunner.getRunner().call(otpArgs,"Could not run typer");
      
      progress.next();// 4
      progress.next();// 5
    }
    catch(ErlangThrownException ex)
    {
      pltFile.delete();
      otpArgs[0] = new OtpErlangAtom("dialyzer");
      progress.next();// 4
      ErlangRunner.getRunner().call(otpArgs, "Could not run dialyzer");
      otpArgs[0] = new OtpErlangAtom("typer");
      progress.next();// 5
      response = ErlangRunner.getRunner().call(otpArgs,"Could not run typer for the second time");      
    }
    progress.next();// 6


    OtpErlangList analysisResults = (OtpErlangList) response.elementAt(1);
    Assert.assertEquals(1, analysisResults.arity());
    OtpErlangTuple fileDetails = (OtpErlangTuple) analysisResults.elementAt(0);
    OtpErlangList typeInformation = (OtpErlangList) fileDetails.elementAt(3);
    for (int i = 0; i < typeInformation.arity(); ++i) {
      //System.out.print("\n" + typeInformation.elementAt(i).toString());
      OtpErlangTuple functionDescr = (OtpErlangTuple) typeInformation.elementAt(i); 
      if (functionDescr.arity() > 3)
      {
        FuncSignature s = new FuncSignature(config,typeInformation.elementAt(i), null);
        sigs.put(s.getQualifiedName(), s);
      }
      else
      {// if not a function signature, it is an error message. The first two elements are function name and arity, we add this module name.
        String fullName = FuncSignature.qualifiedNameFromFunction(getName(),
            ((OtpErlangAtom)functionDescr.elementAt(0)).atomValue(),
            ((OtpErlangLong)functionDescr.elementAt(1)).longValue());
        ignoredFunctions.add( fullName );
        System.out.println("Ignoring: "+fullName+", "+functionDescr.elementAt(2));
      }
    }
    
    behaviour = OTPBehaviour.obtainDeclaredBehaviour(f, this,ignoredBehaviours);
    progress.next();// 7
  }

View Full Code Here

    for(int graphComplexity=0;graphComplexity < graphComplexityMax;graphComplexity++)
    {
      int states=initStates+graphComplexity*20;
      int alphabet = states/2;
      MachineGenerator mg = new MachineGenerator(states, 40, states/10);
      ProgressIndicator progress = new ProgressIndicator(""+states, experimentsPerCategory);
      
      for(int experiment=0;experiment<experimentsPerCategory;experiment++)
      {
        LearnerGraphND generatedFSM = mg.nextMachine(alphabet, experiment,config);
        if (generatedFSM.getInit() != generatedFSM.transitionMatrix.entrySet().iterator().next().getKey())
          throw new RuntimeException("first state is not the initial state");
        
        //Visualiser.updateFrame(origGraph, null);
        Writer randomFSM = new FileWriter("resources/randomFSM/fsm_"+states+"_"+experiment+".x_");
        for(Entry<CmpVertex,Map<Label,List<CmpVertex>>> entry:generatedFSM.transitionMatrix.entrySet())
          for(Entry<Label,List<CmpVertex>> targets:entry.getValue().entrySet())
            for(CmpVertex targetState:generatedFSM.getTargets(targets.getValue()))
            {
              randomFSM.write(entry.getKey().getID().getStringId());randomFSM.write(' ');
              randomFSM.write(targetState.getID().getStringId());randomFSM.write(' ');
              randomFSM.write(targets.getKey().toString());randomFSM.write('\n');
            }
        randomFSM.close();
        
        progress.next();
      }
    }
    }
    catch(Exception ex)
    {

View Full Code Here

    {
     
    /** The runner of computational threads. */
    int threadNumber = ExperimentRunner.getCpuNumber();
    ExecutorService executorService = Executors.newFixedThreadPool(threadNumber);
    ProgressIndicator progress = null;
    List<Future<?>> outcomes = new LinkedList<Future<?>>();
    DrawGraphs gr = new DrawGraphs();
    final Random seedSel = new Random(0);


    final RBoxPlot<String> uas_outcome = new RBoxPlot<String>("Graph","stateNumber",new File("stateNumber.pdf"));
    for(int i=pairchoiceMIN;i<10;++i)
    {
      
      final int arg=i;
      final int seed = seedSel.nextInt();assert seed != PaperUAS.pairchoiceMAX && seed != PaperUAS.pairchoiceMIN;
      Runnable interactiveRunner = new Runnable() {
        
        @Override
        public void run() {
              LearnerGraph graphA=new RPNIVariabilityExperiment(arg<0?arg:seed).learn(UAVAllSeeds, UAVAllSeeds,maxFrameNumber);
              uas_outcome.add("all", (double)graphA.getStateNumber());
        }
      };
      outcomes.add(executorService.submit(interactiveRunner));
    }


    try
    {
      progress = new ProgressIndicator("running concurrent experiment",outcomes.size());
      for(Future<?> task:outcomes) { task.get();progress.next(); }// wait for termination of all tasks
    }
    catch(Exception ex)
    {
      Helper.throwUnchecked("failed to run experiment", ex);
    }

View Full Code Here

    Set<Integer> allFrames = collectionOfTraces.get(UAVAllSeeds).tracesForUAVandFrame.get(UAVAllSeeds).keySet();


    /** The runner of computational threads. */
    int threadNumber = ExperimentRunner.getCpuNumber();
    ExecutorService executorService = Executors.newFixedThreadPool(threadNumber);
    ProgressIndicator progress = null;
    if (threadNumber <= 1)
      progress = new ProgressIndicator("UAS", allFrames.size());
    
    try
    {
      List<Future<?>> outcomes = new LinkedList<Future<?>>();
      for(final Integer frame:allFrames)
      {
        {// For all frames and all seeds
          Runnable interactiveRunner = new Runnable() {
  
            @Override
            public void run() {
              ConfusionMatrix matrix = DiffExperiments.classify(wMethod, graphReference,
                  new RPNIBlueFringe(learnerConfig,useOptimizedMerge,null,null).learn(collectionOfTraces.get(UAVAllSeeds).tracesForUAVandFrame.get(UAVAllSeeds).get(frame),true));
              uas_outcome.add(new Pair<Integer,String>(frame,"S"),matrix.BCR());
              uas_S.add(frame,matrix.BCR());
            }
            
          };
          if (threadNumber > 1) outcomes.add(executorService.submit(interactiveRunner));else interactiveRunner.run();
        }
        
        for(final String seed:collectionOfTraces.keySet())
          if (!seed.equals(UAVAllSeeds))
          {// Just for all frames of the a single seed
            Runnable interactiveRunner = new Runnable() {


              @Override
              public void run() {
                ConfusionMatrix matrix = DiffExperiments.classify(wMethod, graphReference,
                    new RPNIBlueFringe(learnerConfig,useOptimizedMerge,null,null).learn(collectionOfTraces.get(UAVAllSeeds).tracesForUAVandFrame.get(seed).get(frame),true));
                uas_outcome.add(new Pair<Integer,String>(frame,"A"),matrix.BCR());
                uas_A.add(frame,matrix.BCR());
              }
              
            };
            if (threadNumber > 1) outcomes.add(executorService.submit(interactiveRunner));else interactiveRunner.run();
          }
        for(final String UAV:collectionOfTraces.get(UAVAllSeeds).tracesForUAVandFrame.keySet())
          if (!UAV.equals(UAVAllSeeds) && !UAV.equals(UAVAll))
            for(final String seed:collectionOfTraces.keySet())
              if (!seed.equals(UAVAllSeeds))
              {
                Runnable interactiveRunner = new Runnable() {


                  @Override
                  public void run() {
                    ConfusionMatrix matrix = DiffExperiments.classify(wMethod, graphReference,
                        new RPNIBlueFringe(learnerConfig,useOptimizedMerge,null,null).learn(collectionOfTraces.get(UAV).tracesForUAVandFrame.get(seed).get(frame),true));
                    uas_outcome.add(new Pair<Integer,String>(frame,"U"),matrix.BCR());
                    uas_U.add(frame,matrix.BCR());
                  }
                  
                };
                if (threadNumber > 1) outcomes.add(executorService.submit(interactiveRunner));else interactiveRunner.run();
              }
        
        if (threadNumber <= 1)
        {
          uas_outcome.drawInteractive(gr);
          uas_A.drawInteractive(gr);
          uas_S.drawInteractive(gr);
          uas_U.drawInteractive(gr);
          progress.next();
        }
      }
      
      for(int i=0;i<5;++i)
      {
        final int arg=i;
        Runnable interactiveRunner = new Runnable() {


          @Override
          public void run() {
            Configuration tmpConf = learnerConfig.copy();tmpConf.setGeneralisationThreshold(arg);
            ConfusionMatrix matrix = DiffExperiments.classify(wMethod, graphReference,new RPNIBlueFringe(tmpConf,useOptimizedMerge,null,null).learn(collectionOfTraces.get(UAVAllSeeds).tracesForUAVandFrame.get(UAVAllSeeds).get(maxFrameNumber),false));
            uas_threshold.add(arg, matrix.BCR());
          }
          
        };
        if (threadNumber > 1) 
          outcomes.add(executorService.submit(interactiveRunner));
        else 
        { 
          interactiveRunner.run();
          uas_threshold.drawInteractive(gr);
        }
      }


      if (threadNumber > 1)
      {
        progress = new ProgressIndicator("running concurrent experiment",outcomes.size());
        for(Future<?> task:outcomes) { task.get();progress.next(); }// wait for termination of all tasks
      }
    }
    catch(Exception ex)
    {
      Helper.throwUnchecked("failed to run experiment", ex);

View Full Code Here

      uas_Diff=new RBoxPlot<String>("Time","Diff-measure",new File("time_"+name+"_Diff.pdf"));
    SquareBagPlot gr_diff_to_f = new SquareBagPlot("f-measure","diff-based measure",new File("diff-to-f.pdf"),0,1,true);


    Set<Integer> allFrames = collectionOfTraces.get(UAVAllSeeds).tracesForUAVandFrame.get(UAVAllSeeds).keySet();
    Classifier classifiers[] = loadClassifierFromArff(arffName);
    ProgressIndicator progress = new ProgressIndicator("UAS", allFrames.size()*classifiers.length);
    LearnerEvaluationConfiguration initConfiguration = new LearnerEvaluationConfiguration(learnerInitConfiguration.config);
    initConfiguration.setLabelConverter(learnerInitConfiguration.getLabelConverter());// we do not copy if-then automata here because we do not wish to augment from if-then on every iteration because our properties are pairwise and this permits augmentation to be carried out first thing and not any more.
    initConfiguration.config.setUseConstraints(false);// do not use if-then during learning (refer to the explanation above)
    
    LearnerGraph [] ifthenAutomata = Transform.buildIfThenAutomata(learnerInitConfiguration.ifthenSequences, null, referenceGraph, learnerInitConfiguration.config, learnerInitConfiguration.getLabelConverter()).toArray(new LearnerGraph[0]);

View Full Code Here

                  learnerRunner.setOnlyUsePositives(onlyPositives);learnerRunner.setLengthMultiplier(lengthMultiplier);
                  learnerRunner.setSelectionID(selection+"_states"+states+"_sample"+sample);
                  runner.submit(learnerRunner);
                  ++numberOfTasks;
                }
              ProgressIndicator progress = new ProgressIndicator(new Date()+" evaluating "+numberOfTasks+" tasks for "+selection, numberOfTasks);
              for(int count=0;count < numberOfTasks;++count)
              {
                ThreadResult result = runner.take().get();// this will throw an exception if any of the tasks failed.
                if (gr_NewToOrig != null)
                {
                  for(SampleData sample:result.samples)
                    gr_NewToOrig.add(sample.differenceForReferenceLearner.getValue(),sample.difference.getValue());
                }
                
                for(SampleData sample:result.samples)
                  if (sample.differenceForReferenceLearner.getValue() > 0)
                    gr_QualityForNumberOfTraces.add(traceQuantity+"",sample.difference.getValue()/sample.differenceForReferenceLearner.getValue());
                progress.next();
              }
              if (gr_PairQuality != null)
              {
                synchronized(pairQualityCounter)
                {

View Full Code Here

0 1 2 3 4 5 6 7

TOP

Related Classes of statechum.ProgressIndicator

statechum.analysis.Erlang.ErlangModule

statechum.analysis.Erlang.TestErlangRunner

statechum.analysis.learning.experiments.mutation.DiffExperiments

statechum.analysis.learning.experiments.mutation.GenerateRandomFSM

statechum.analysis.learning.experiments.mutation.TestDiffExperimentWithLogs$SystemTestDiffExperiments

statechum.analysis.learning.experiments.PairSelection.ASE2014

statechum.analysis.learning.experiments.PairSelection.Cav2014

statechum.analysis.learning.experiments.PairSelection.MarkovPassivePairSelection

statechum.analysis.learning.experiments.PairSelection.PairQualityLearner

statechum.analysis.learning.experiments.PairSelection.WaveBlueFringe

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.