Package statechum.DeterministicDirectedSparseGraph

Examples of statechum.DeterministicDirectedSparseGraph.CmpVertex


            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;
           
View Full Code Here


  public static ConfusionMatrix classify(Collection<List<Label>> sequences,LearnerGraph from, LearnerGraph to)
  {
    int tp=0, tn = 0, fp=0, fn=0;
    boolean inTarget,inMutated;
    for (List<Label> list : sequences) {
      CmpVertex fromState = from.paths.getVertex(list);
      if(fromState==null)
        inTarget = false;
      else
        inTarget = fromState.isAccept();
      CmpVertex toState = to.paths.getVertex(list);
      if(toState == null)
        inMutated= false;
      else
        inMutated = toState.isAccept();
      if(inTarget && inMutated)
        tp++;
      else if(inTarget && !inMutated)
        fn++;
      else if(!inTarget && inMutated)
View Full Code Here

  protected Map<CmpVertex,CmpVertex> copyStatesAndTransitions(LearnerGraphND machineFrom, LearnerGraphND graphTo) {
    Map<CmpVertex,CmpVertex> machineVertexToGraphVertex = new HashMap<CmpVertex,CmpVertex>();
    graphTo.getTransitionMatrix().clear();
    Set<CmpVertex> machineStates = machineFrom.getTransitionMatrix().keySet();
    for (CmpVertex cmpVertex : machineStates) { //copy all vertices
      CmpVertex newVertex = AbstractLearnerGraph.generateNewCmpVertex(VertexID.parseID("o"+cmpVertex.getStringId()), graphTo.config);
      DeterministicDirectedSparseGraph.copyVertexData(cmpVertex, newVertex);
      machineVertexToGraphVertex.put(cmpVertex, newVertex);
    }
    graphTo.setInit(machineVertexToGraphVertex.get(machineFrom.getInit()));
    AbstractLearnerGraph.addAndRelabelGraphs(machineFrom, machineVertexToGraphVertex, graphTo);
View Full Code Here

    Queue<CmpVertex> fringe = new LinkedList<CmpVertex>();
    Set<CmpVertex> statesInFringe = new HashSet<CmpVertex>();
    fringe.add(stateToStartFrom);statesInFringe.add(stateToStartFrom);
    while(!fringe.isEmpty())
    {
      CmpVertex currentState = fringe.remove();
      Map<Label,CmpVertex> targets = graph.transitionMatrix.get(currentState);
      if(targets != null && !targets.isEmpty())
        for(Entry<Label,CmpVertex> labelstate:targets.entrySet())
          for(CmpVertex target:graph.getTargets(labelstate.getValue()))
          {
View Full Code Here

   
    int firstCorrectPair = JUConstants.intUNKNOWN, cnt=0;
    for(PairScore p:pairs)
    {
      CmpVertex blue = correctGraph.getVertex(stateToPath.get(p.getQ()));if (blue != null && !blue.isAccept()) blue = null;
      CmpVertex red = correctGraph.getVertex(stateToPath.get(p.getR()));if (red != null && !red.isAccept()) red = null;
      if (blue == red)
      {
        // it would be right to merge this pair.
        correctPairs.add(p);
        if (firstCorrectPair == JUConstants.intUNKNOWN)
View Full Code Here

    Set<Label> deadLabels = new HashSet<Label>();
   
    Map<Label,CmpVertex> labelToState = new TreeMap<Label,CmpVertex>();
    for(Entry<CmpVertex,Map<Label,CmpVertex>> entry:graph.transitionMatrix.entrySet())
    {
      CmpVertex state = entry.getKey();
      for(Entry<Label,CmpVertex> target:entry.getValue().entrySet())
        if (!deadLabels.contains(target.getKey()))
        {// the label is not already recorded as leading to multiple different states.
          CmpVertex recordedState = labelToState.get(target.getKey());
            if (recordedState == null)
              // first time we've seen this label in use
              labelToState.put(target.getKey(),state);
            else
              if (recordedState != state)
View Full Code Here

  {
    LearnerGraphND ptaInverse = new LearnerGraphND(graph.config);
    AbstractPathRoutines.buildInverse(graph, new StatesToConsider() {
      @Override public boolean stateToConsider(@SuppressWarnings("unused") CmpVertex v) { return true; }}
      , ptaInverse);
    CmpVertex v=ptaInverse.findVertex(vert);
    for(int i=0;i<10;++i)
    {
      Map<Label,List<CmpVertex>> transitions = ptaInverse.transitionMatrix.get(v);
      if (transitions.size() > 1)
      {
        System.out.println(transitions);break;
      }
      List<CmpVertex> next = transitions.entrySet().iterator().next().getValue();
      if (next.size() > 1)
      {
        System.out.println(next);break;
      }
      CmpVertex nextState = next.iterator().next();
      System.out.println(v+"-"+transitions.entrySet().iterator().next().getKey()+"->"+nextState);
      v  = nextState;
    }
   
  }
View Full Code Here

          }

    for(CmpVertex vert:sourceStates)
      if (vert != pta.getInit())
      {
        CmpVertex newSource = AbstractLearnerGraph.generateNewCmpVertex(pta.nextID(true), pta.config);
        Map<Label,CmpVertex> row = pta.createNewRow();
        pta.transitionMatrix.put(newSource,row);row.put(uniqueFromInitial, pta.transitionMatrix.get(vert).get(uniqueFromInitial));
        statesOfInterest.add(newSource);
       
        CmpVertex tailState = AbstractLearnerGraph.generateNewCmpVertex(pta.nextID(true), pta.config);
        Map<Label,CmpVertex> tailRow = pta.createNewRow();
        pta.transitionMatrix.put(tailState,tailRow);pta.transitionMatrix.get(vert).put(uniqueFromInitial,tailState);
      }
      else
        statesOfInterest.add(vert);
View Full Code Here

            final Set<CmpVertex> deadendStates = machine.pathroutines.computeReachableStatesFromWhichInitIsNotReachable();
            final Set<Label> alphabetObtained = machine.pathroutines.computeAlphabet();
            for(CmpVertex v:deadendStates)
            {
              Set<CmpVertex> visited = new HashSet<CmpVertex>();visited.addAll(machine.transitionMatrix.keySet());visited.removeAll(machine.transitionMatrix.get(v).values());visited.remove(v);
              CmpVertex possibleStates [] = visited.toArray(new CmpVertex[]{});
              CmpVertex chosenState = null;
              assert possibleStates.length > 0;// at least the initial state is not reachable
              if (possibleStates.length < 2)
                chosenState = possibleStates[0];
              else
                chosenState = possibleStates[connectTransitions.nextInt(possibleStates.length)];
View Full Code Here

 
  @Test(expected = IllegalArgumentException.class)
  public final void testMerge_fail1a()
  {
    DirectedSparseGraph g=TestFSMAlgo.buildGraph(largeGraph1_invalid5,"testMerge_fail1");
    CmpVertex
      a = DeterministicDirectedSparseGraph.findVertexNamed(new VertexID("A"), g),
      b = DeterministicDirectedSparseGraph.findVertexNamed(new VertexID("B"), g);
    StatePair pair = new StatePair(b,a);// A is red
    MergeStates.mergeAndDeterminize(g, pair,testConfig);
  }
View Full Code Here

TOP

Related Classes of statechum.DeterministicDirectedSparseGraph.CmpVertex

Copyright © 2018 www.massapicom. All rights reserved.
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.