Package statechum.analysis.learning.rpnicore.AbstractLearnerGraph

Examples of statechum.analysis.learning.rpnicore.AbstractLearnerGraph.StatesToConsider

889
890
891
892
893
894
895
896
897
898
899
  public <TARGET_A_TYPE,CACHE_A_TYPE extends CachedData<TARGET_A_TYPE,CACHE_A_TYPE>> void removeReachableStatesFromWhichInitIsNotReachable(AbstractLearnerGraph<TARGET_A_TYPE,CACHE_A_TYPE> outcome)
  {
    final Set<CmpVertex> reachableStates = computeReachableStatesFromWhichInitIsNotReachable();
   
    buildForward(coregraph, new StatesToConsider(){

      @Override
      public boolean stateToConsider(CmpVertex vert) {
        return !reachableStates.contains(vert);
      }}, outcome);
View Full Code Here
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
  }
 
  public static void printTraceLeadingTo(LearnerGraph graph, String vert)
  {
    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)
    {
View Full Code Here
154
155
156
157
158
159
160
161
162
163
164
  /** Tests the workload distribution. */
  @Test
  public final void testPerformRowTasks_A_1()
  {
    LearnerGraph gr=new LearnerGraph(Configuration.getDefaultConfiguration());gr.init.setAccept(false);
    StatesToConsider filter = LearnerGraphND.ignoreRejectStates;
    GDLearnerGraph ndGraph = new GDLearnerGraph(gr,filter, false);
    int ThreadNumber=4;
    Assert.assertArrayEquals(new int[]{0,0,0,0,0},GDLearnerGraph.partitionWorkLoadTriangular(ThreadNumber,ndGraph.getStateNumber()));
    Assert.assertArrayEquals(new int[]{0,0,0,0,0},GDLearnerGraph.partitionWorkLoadLinear(ThreadNumber,ndGraph.getStateNumber()));

View Full Code Here
192
193
194
195
196
197
198
199
200
201
202
  /** Tests the workload distribution. */
  @Test
  public final void testPerformRowTasks_A_2()
  {
    LearnerGraph gr=new LearnerGraph(Configuration.getDefaultConfiguration());
    StatesToConsider filter = LearnerGraphND.ignoreRejectStates;
    GDLearnerGraph ndGraph = new GDLearnerGraph(gr,filter, false);
    int ThreadNumber=4;
    Assert.assertArrayEquals(new int[]{0,0,0,0,1},GDLearnerGraph.partitionWorkLoadTriangular(ThreadNumber,ndGraph.getStateNumber()));

    final Map<Integer,Integer> threadToRowNumber = new TreeMap<Integer,Integer>(); 
View Full Code Here
230
231
232
233
234
235
236
237
238
239
240
  /** Tests the workload distribution. */
  @Test
  public final void testPerformRowTasks_A_3()
  {
    LearnerGraph gr=new LearnerGraph(buildGraph("A-a->B-a-#C\nA-b-#D\nA-c-#E\nB-b-#F\nB-c-#G","testPerformRowTasks_A_3"),Configuration.getDefaultConfiguration());
    StatesToConsider filter = LearnerGraphND.ignoreRejectStates;
    GDLearnerGraph ndGraph = new GDLearnerGraph(gr,filter, false);
    int ThreadNumber=4;


    final Map<Integer,Integer> threadToRowNumber = new TreeMap<Integer,Integer>(); 
View Full Code Here
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
  /** Tests that conversion between numerical state pairs and back works. */
  @Test
  public final void testNumberToState_and_Back()
  {
    LearnerGraph gr=new LearnerGraph(buildGraph("A-a->Q\nA-b->C\nA-d->C\nD-a->C\nD-b->C\nD-d->C-a->C\nD-c->A-c-#R\nC-f-#T\nC-e->G-a-#K\nG-b->S-a-#U","TestFindIncompatibleStatesB"),Configuration.getDefaultConfiguration());
    StatesToConsider filter = LearnerGraphND.ignoreRejectStates;
    GDLearnerGraph ndGraph = new GDLearnerGraph(gr,filter, false);
    for(CmpVertex A:gr.transitionMatrix.keySet())
      if (filter.stateToConsider(A))
        for(CmpVertex B:gr.transitionMatrix.keySet())
          if (filter.stateToConsider(B))
          {
            PairScore received1 = ndGraph.getPairScore(ndGraph.vertexToIntNR(A,B), 1, 2);
            Assert.assertTrue(
                received1.equals(new PairScore(A,B,1,2)) ||
                received1.equals(new PairScore(B,A,1,2))
View Full Code Here
479
480
481
482
483
484
485
486
487
488
489
   *
   * @return an instance of filter.
   */
  public static StatesToConsider createInstanceOfFilter(Class<? extends StatesToConsider> filterClass,LearnerGraph gr)
  {
    StatesToConsider filter = null;
    try {
      java.lang.reflect.Constructor<? extends StatesToConsider> constructor = filterClass.getConstructor(new Class []{});
      filter = constructor.newInstance(new Object[]{});
    } catch (Exception e) {
      // if we failed, filter stays at null, we'll try again.
View Full Code Here
507
508
509
510
511
512
513
514
515
516
517
   * @param expectedIgnored which states are expected to remain after filtering.
   */
  private final void checkConsideringIgnoredStates(String graph, String graphName, Class<? extends StatesToConsider> filterClass, String [] expectedIgnored)
  {
    LearnerGraph gr=new LearnerGraph(buildGraph(graph,graphName),Configuration.getDefaultConfiguration());
    StatesToConsider filter = createInstanceOfFilter(filterClass, gr);
    for(boolean direction:new boolean[]{false,true})
    {
      GDLearnerGraph ndGraph = new GDLearnerGraph(gr,filter, direction);
      Map<CmpVertex,Integer> state_to_int_map = new TreeMap<CmpVertex,Integer>();
      CmpVertex [] numberToStateNoReject = gr.buildStateToIntegerMap(filter,state_to_int_map);
View Full Code Here
127
128
129
130
131
132
133
134
135
136
137
 
  protected DoubleMatrix1D getExpectedMatrix1DSlowly(LearnerGraph gr)
  {
    int size=gr.getStateNumber()*(gr.getStateNumber()+1)/2;
    DoubleMatrix1D result = DoubleFactory1D.dense.make(size);
    StatesToConsider filter = LearnerGraphND.ignoreRejectStates;
    GDLearnerGraph ndGraph = new GDLearnerGraph(gr,filter, false);
    DetermineDiagonalAndRightHandSide ddrhInstance = ndGraph.new DDRH_default();
    for(Entry<CmpVertex,Map<Label,List<CmpVertex>>> entryA:ndGraph.matrixForward.transitionMatrix.entrySet())
    {
      // Now iterate through states
View Full Code Here
153
154
155
156
157
158
159
160
161
162
163
  protected DoubleMatrix2D getExpectedMatrix2DSlowly(LearnerGraph gr)
  {
    int size=gr.getStateNumber()*(gr.getStateNumber()+1)/2;
    DoubleMatrix2D result = DoubleFactory2D.sparse.make(size,size,0);
    StatesToConsider filter = LearnerGraphND.ignoreRejectStates;
    GDLearnerGraph ndGraph = new GDLearnerGraph(gr,filter, false);
    for(Entry<CmpVertex,Map<Label,List<CmpVertex>>> entryA:ndGraph.matrixForward.transitionMatrix.entrySet())
    {
      // Now iterate through states
      Iterator<Entry<CmpVertex,Map<Label,List<CmpVertex>>>> stateB_It = ndGraph.matrixForward.transitionMatrix.entrySet().iterator();
View Full Code Here
TOP

Related Classes of statechum.analysis.learning.rpnicore.AbstractLearnerGraph.StatesToConsider

  • statechum.analysis.learning.experiments.PairSelection.PairQualityLearner
  • statechum.analysis.learning.linear.GD
  • statechum.analysis.learning.linear.TestLinear
  • statechum.analysis.learning.linear.TestLinearWithMultipleThreads
  • statechum.analysis.learning.linear.TestMatrixComputationWithMultipleThreads
  • statechum.analysis.learning.rpnicore.AbstractPathRoutines
  • statechum.analysis.learning.rpnicore.GD
  • statechum.analysis.learning.rpnicore.TestLearnerGraphND
  • statechum.analysis.learning.rpnicore.TestLinear
  • statechum.analysis.learning.rpnicore.TestLinearWithMultipleThreads
    • 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.