示例#1
0
        TEST(wali$wfa$$WFA$$semideterminize, weightGenAcceptingStates)
        {
            sem_elem_t reach_one = Reach(true).one();
            sem_elem_t reach_zero = Reach(true).zero();

            Letters letters;
            Key start = getKey("start"),
                acc1 = getKey("acc1"),
                acc2 = getKey("acc2"),
                rej = getKey("rej");

            //  --> start -----> ((acc1))
            //       |  |
            //       |  +------> ((acc2))
            //       |
            //       +---------> rej
            
            WFA nondet;

            nondet.addState(start, reach_zero);
            nondet.addState(acc1, reach_zero);
            nondet.addState(acc2, reach_zero);
            nondet.addState(rej, reach_zero);

            nondet.setInitialState(start);
            nondet.addFinalState(acc1);
            nondet.addFinalState(acc2);

            nondet.addTrans(start, letters.a, acc1, reach_one);
            nondet.addTrans(start, letters.a, acc2, reach_one);
            nondet.addTrans(start, letters.a, rej, reach_one);

            

            WFA det = nondet.semideterminize(TestLifter());

            // Sanity checks
            std::set<Key> start_set, fin_set;
            start_set.insert(start);
            fin_set.insert(acc1);
            fin_set.insert(acc2);
            fin_set.insert(rej);

            Key start_set_key = getKey(start_set),
                fin_set_key = getKey(fin_set);

            ASSERT_EQ(2u, det.getStates().size());
            ASSERT_CONTAINS(det.getStates(), start_set_key);
            ASSERT_CONTAINS(det.getStates(), fin_set_key);

            // Extract the transition, then the weight
            StringWeight * w = dynamic_cast<StringWeight*>(det.getState(fin_set_key)->acceptWeight().get_ptr());
            ASSERT_TRUE(w != NULL);

            // Test. This is maybe a fragile (though not as much as before)...
            EXPECT_EQ(" | acc1 | acc2", w->str);
        }
示例#2
0
        TEST(wali$wfa$$isIsomorphicTo, isomorphismChecksStateWeights)
        {
            sem_elem_t one = Reach(true).one();
            sem_elem_t zero = Reach(true).zero();
            
            Letters l;
            WFA w0, w1;

            w0.addState(l.a, zero);
            w1.addState(l.a, one);

            EXPECT_FALSE(w0.isIsomorphicTo(w1));
        }
示例#3
0
        TEST(wali$wfa$$isIsomorphicTo, isomorphismIgnoresStateWeightsWhenCheckWeghtsIsFalse)
        {
            sem_elem_t one = Reach(true).one();
            sem_elem_t zero = Reach(true).zero();
            
            Letters l;
            WFA w0, w1;

            w0.addState(l.a, zero);
            w1.addState(l.a, one);

            EXPECT_TRUE(w0.isIsomorphicTo(w1, false));
        }
示例#4
0
        TEST(wali$wfa$$semideterminize, initialStateGetsLabeledWithTheCorrectKindOfWeight)
        {
            //      zero
            //  -> A ---> (B)
            Key A = getKey("A");
            Key B = getKey("B");

            sem_elem_t zero = Reach(true).zero();

            WFA wfa;
            wfa.addState(A, zero);
            wfa.addState(B, zero);
            wfa.addTrans(A, A, B, zero);

            wfa.setInitialState(A);
            wfa.addFinalState(B);

            WFA det = wfa.semideterminize(TestLifter());
            
            sem_elem_t initial_weight = det.getState(det.getInitialState())->weight();

            Reach * reach = dynamic_cast<Reach*>(initial_weight.get_ptr());
            StringWeight * str = dynamic_cast<StringWeight*>(initial_weight.get_ptr());

            EXPECT_EQ(NULL, reach);
            EXPECT_TRUE(str != NULL);
        }
示例#5
0
        // FIXME: this isn't a test!
        TEST(wali$wfa$$semideterminize, zeroWeightPathDoesNotAccept)
        {
            //      zero
            //  -> A ---> (B)
            Key A = getKey("A");
            Key B = getKey("B");

            sem_elem_t zero = Reach(true).zero();

            WFA wfa;
            wfa.addState(A, zero);
            wfa.addState(B, zero);
            wfa.addTrans(A, A, B, zero);

            wfa.setInitialState(A);
            wfa.addFinalState(B);

            WFA det = wfa.semideterminize();

            wfa.print(std::cerr);
            det.print(std::cerr);

            WFA::Word w;
            w.push_back(A);

            std::cerr << "wfa accepts: " << wfa.isAcceptedWithNonzeroWeight(w) << "\n";
            std::cerr << "det accepts: " << det.isAcceptedWithNonzeroWeight(w) << "\n";
        }
示例#6
0
int Reaching::StartRecordTraj(joint_vec_t& initpos){
  if(SetActualRobPosition(initpos)){
    return Reach();
  }
  else{
    return -1; //unvalid init position
  }
} 
示例#7
0
        TEST(wali$wfa$$isIsomorphicTo, loopRejectAndSimilar)
        {
            LoopReject f;
            WFA wfa;

            sem_elem_t one = Reach(true).one();
            sem_elem_t zero = Reach(true).zero();
                
            Letters l;
            Key state = getKey("different state");
            ASSERT_NE(state, f.state);

            wfa.addState(state, zero);
            wfa.setInitialState(state);
            wfa.addTrans(state, l.a, state, one);
            wfa.addTrans(state, l.b, state, one);
            wfa.addTrans(state, l.c, state, one);
            
            EXPECT_TRUE(f.wfa.isIsomorphicTo(wfa));
        }
示例#8
0
void
GlideComputerRoute::ProcessRoute(const MoreData &basic,
                                 DerivedInfo &calculated,
                                 const DerivedInfo &last_calculated,
                                 const RoutePlannerConfig &config,
                                 const GlidePolar &glide_polar,
                                 const GlidePolar &safety_polar)
{
  protected_route_planner.SetPolars(glide_polar, safety_polar,
                                    calculated.wind);

  Reach(basic, calculated, config);
  TerrainWarning(basic, calculated, last_calculated, config);
}
示例#9
0
void
RouteComputer::ProcessRoute(const MoreData &basic, DerivedInfo &calculated,
                            const GlideSettings &settings,
                            const RoutePlannerConfig &config,
                            const GlidePolar &glide_polar,
                            const GlidePolar &safety_polar)
{
  if (!basic.location_available || !basic.NavAltitudeAvailable())
    return;

  protected_route_planner.SetPolars(settings, glide_polar, safety_polar,
                                    calculated.GetWindOrZero());

  Reach(basic, calculated, config);
  TerrainWarning(basic, calculated, config);
}
示例#10
0
void Climber_Class::AutoClimb(int state)
{	
	bool climb;
	bool reach;
	bool pushOut;
	bool safety;
	bool release;
	
	switch(state)
	{
	case AUTO_CLIMB_STATE_1:
		//brings the towers stationary hooks all the way up
		//The towers need to be reset, but only once
		/*if(firstReach)
		{
			ResetTowers();
			firstReach = false;
		}*/
		if(startCC)
		{
			ResetTowers();
			startCC = false;
		}
		inState = ReachDistance(LEVEL_1A_REACH_POS);
		break;
	case AUTO_CLIMB_STATE_2:
		//pushes the candy cane out
		inState = (bool)candyCane->PushOut();
		//The startCC boolean only allows the CC functions to be called once per state
		startCC = true;
		break;
	case AUTO_CLIMB_STATE_3:
		//Reset the towers so we know we can move them in the next state
		ResetTowers();
		TowersStop();
		//Grab the pole
		if(startCC)
		{
			candyCane->StartGrab(LEVEL_1_GRAB_POS);
			//This line makes the CC only grab once
			startCC = false;
		}
		//If we're done grabbing, inState will be false and we can go to the next state otherwise it will be true
		inState = (bool)candyCane->Grab();
		break;
	case AUTO_CLIMB_STATE_4:
		//climb until arms grab the horizontal bar
		
		//If we're still climbing inState is set to true, otherwise it is set to false
		inState = (bool)ClimbDistance(LEVEL_1A_CLIMB_POS);
		//Tell the CC it can move in the next state
		startCC = true;
		break;
	case AUTO_CLIMB_STATE_5:
		//Release the CC
		if(startCC)
		{
			//Reset the towers so we know we can move them in the next state
			ResetTowers();
			TowersStop();
			candyCane->StartRelease();
			startCC = false;
			release = true;
			climb = true;
		}
		//If we're done releasing, inState will be set to false so we can go to the next state, otherwise it will be true
		release = (bool)candyCane->Release();
		climb = (bool)Climb();
		
		if(!climb && !release)
		{
			inState = false;
		}
		break;
	/*case AUTO_CLIMB_STATE_6:	
		//Climb until the hooks transition
		//Check to see if we're still climbing
		inState = (bool)Climb();
		break;*/
	case AUTO_CLIMB_STATE_6:
		//Reach until the CC is clear
		if(startCC)
		{
			reach = true;
			pushOut = true;
			startCC = false;
			bringOutCC = true;
		}
		//Check to see if we're still reaching
		reach = (bool)ReachDistance(LEVEL_2A_REACH_POS);

		//Once the towers reached a certain distance, push out the CC
		if((leftTower->GetDistance() >= DISTANCE_FOR_EXTENDEING_CC) && bringOutCC)
		{
			candyCane->StartSafety(LEVEL_2A_SAFETY_POS);
			bringOutCC = false;
		}
		pushOut = candyCane->Safety();
		//If we're not reaching or pushing out, we're not in the state anymore
		if(!reach && !pushOut)
		{
			inState = false;
		}
		/*//Check to see if we're still reaching
		inState = (bool)ReachDistance(LEVEL_2A_REACH_POS);
		//Tell the CC it can move in the next state
		startCC = true;*/
		break;
	//Level 2
	/*case AUTO_CLIMB_STATE_7:
		//CC safety position
		if(startCC)
		{
			candyCane->StartSafety(LEVEL_2A_SAFETY_POS);
			//This line makes the CC go into the safety position only once
			startCC = false;
		}
		inState = (bool)candyCane->Safety();
		break;*/
	case AUTO_CLIMB_STATE_7:
		//Reset the towers so we know we can move them in the next state
		ResetTowers();
		TowersStop();
		//Bring in the CC so the servo turns
		if(startCC)
		{
			candyCane->StartLeanIn(LEVEL_2A_SAFETY_LEAN_POS);
			startCC = false;
		}
		inState = (bool)candyCane->LeanIn();
		break;
	case AUTO_CLIMB_STATE_8:
		//Reach until the CC grabs the vertical bar
		//Check to see if we're still reaching
		inState = (bool)ReachDistance(LEVEL_2B_REACH_POS);
		//Tell the CC it can move in the next state
		startCC = true;
		break;
	case AUTO_CLIMB_STATE_9:
		//Reset the towers so we know we can move them in the next state
		ResetTowers();
		TowersStop();
		//Lean a little bit
		if(startCC)
		{
			candyCane->StartLeanIn(LEVEL_2A_LEAN_POS);
			startCC = false;
		}
		//Check to see if we're still leaning in
		inState = (bool)candyCane->LeanIn();
		break;
	case AUTO_CLIMB_STATE_10:
		//Reach all the way
		//Check to see if we're still reaching
		inState = (bool)Reach();
		startCC = true;
		break;
	case AUTO_CLIMB_STATE_11:
		//Reset the towers so we know we can move them in the next state
		ResetTowers();
		TowersStop();
		//Lean in until the arms touch the horizontal bars
		if(startCC)
		{
			candyCane->StartLeanIn(LEVEL_2B_LEAN_POS);
			startCC = false;
		}
		//Check to see if we're still leaning in
		inState = (bool)candyCane->LeanIn();
		break;
	case AUTO_CLIMB_STATE_12:
		//climb until the arms grab the horizontal bars
		//Check to see if we're still climbing
		inState = (bool)ClimbDistance(LEVEL_2A_CLIMB_POS);
		startCC = true;
		break;
	/*case AUTO_CLIMB_STATE_14:
		//Reset the towers so we know we can move them in the next state
		ResetTowers();
		TowersStop();
		//CC safety
		if(startCC)
		{
			candyCane->StartSafety(LEVEL_2B_SAFETY);
			startCC = false;
		}
		//Check to see if we're still safetying
		inState = (bool)candyCane->Safety();
		break;*/
	case AUTO_CLIMB_STATE_13:
		//Release the CC
		if(startCC)
		{
			//Reset the towers so we know we can move them in the next state
			ResetTowers();
			TowersStop();
			candyCane->StartRelease();
			startCC = false;
			climb = true;
			release = true;
		}
		//Climb until the hooks transition
		//Check to see if we're still climbing
		climb = (bool)Climb();
		release = (bool)candyCane->Release();
		
		if(!climb && !release)
		{
			inState = false;
		}
		break;
	/*case AUTO_CLIMB_STATE_16:
		//Reset the towers so we know we can move them in the next state
		ResetTowers();
		TowersStop();
		//Release the CC
		if(startCC)
		{
			candyCane->StartRelease();
			startCC = false;
		}
		//Check to see if we're still releasing
		inState = (bool)candyCane->Release();
		break;*/
	//Level 3
	case AUTO_CLIMB_STATE_14:
		//Reach until the CC is clear
		if(startCC)
		{
			reach = true;
			pushOut = true;
			bringOutCC = true;
			startCC = false;
		}
		//Check to see if we're still reaching
		reach = (bool)ReachDistance(LEVEL_3A_REACH_POS);

		//Once the towers reached a certain distance, push out the CC
		if((leftTower->GetDistance() >= DISTANCE_FOR_EXTENDEING_CC) && bringOutCC)
		{
			candyCane->StartSafety(LEVEL_3A_SAFETY_POS);
			bringOutCC = false;
		}
		pushOut = candyCane->Safety();
		
		//If we're not reaching or pushing out, we're not in the state anymore
		if(!reach && !pushOut)
		{
			inState = false;
		}
		/*//Check to see if we're still reaching
		inState = (bool)ReachDistance(LEVEL_3A_REACH_POS);
		startCC = true;*/
		break;
	/*case AUTO_CLIMB_STATE_16:
		//CC safety
		if(startCC)
		{
			candyCane->StartSafety(LEVEL_3A_SAFETY_POS);
			startCC = false;
		}
		//Check to see if we're still safetying
		inState = (bool)candyCane->Safety();
		break;*/
	case AUTO_CLIMB_STATE_15:
		//Reset the towers so we know we can move them in the next state
		ResetTowers();
		TowersStop();
		//Bring in the CC so the servo turns
		if(startCC)
		{
			candyCane->StartLeanIn(LEVEL_3A_SAFETY_LEAN_POS);
			startCC = false;
		}
		inState = (bool)candyCane->LeanIn();
		break;
	case AUTO_CLIMB_STATE_16:
		//Reach until the CC grabs the verticle bar
		//Check to see if we're still reaching
		inState = (bool)ReachDistance(LEVEL_3B_REACH_POS);
		startCC = true;
		break;
	case AUTO_CLIMB_STATE_17:
		//Reset the towers so we know we can move them in the next state
		ResetTowers();
		TowersStop();
		//Lean in
		if(startCC)
		{
			candyCane->StartLeanIn(LEVEL_3A_LEAN_POS);
			startCC = false;
		}
		//Check to see if we're still leaning in
		inState  = (bool)candyCane->LeanIn();
		break;
	case AUTO_CLIMB_STATE_18:
		//Reach all the way
		//Check to see if we're still reaching
		inState = (bool)Reach();
		startCC = true;
		break;
	case AUTO_CLIMB_STATE_19:
		//Reset the towers so we know we can move them in the next state
		ResetTowers();
		TowersStop();
		//Lean in until the arms hit the horizontal bar
		if(startCC)
		{
			candyCane->StartLeanIn(LEVEL_3B_LEAN_POS);
			startCC = false;
		}
		//Check to see if we're still leaning in
		inState = (bool)candyCane->LeanIn();
		break;
	case AUTO_CLIMB_STATE_20:
		//climb until the arms grab the horizontal bars
		//Check to see if we're still climbing
		inState = (bool)ClimbDistance(LEVEL_3A_CLIMB_POS);
		startCC = true;
		break;
	case AUTO_CLIMB_STATE_21:
		//CC safety
		if(startCC)
		{
			//Reset the towers so we know we can move them in the next state
			ResetTowers();
			TowersStop();
			candyCane->StartSafety(LEVEL_3B_SAFETY_POS);
			startCC = false;
			safety = true;
			climb = true;
		}
		//Check to see if we're still safetying
		safety = (bool)candyCane->Safety();
		climb = (bool)ClimbDistance(LEVEL_3B_CLIMB_POS);
		
		if(!safety && !climb)
		{
			inState = false;
		}
		break;
	/*case AUTO_CLIMB_STATE_27:
		//Climb until we want to stop and win
		////Check to see if we're still climbing
		inState = (bool)ClimbDistance(LEVEL_3B_CLIMB_POS);
		break;*/
	}
	/*grabbing = (bool)candyCane->Grab();
	safetying = (bool)candyCane->Safety();
	releasing = (bool)candyCane->Release();
	leaningIn = (bool)candyCane->LeanIn();*/
}