Example #1
0
		/// includes tests for getNumberOfStates/Inputs/Outputs()
		/// and confirms generate(), removeTransition(), removeState()
		void tGenerateSaveLoad() {
			DEBUG_MSG("Generate: %s", machineTypeNames[fsm->getType()]);
			fsm->generate(0, 0, 0);// = create(1,1,1) is minimum
			/// ERR: <type>::generate - the number of states needs to be greater than 0 (set to 1)
			/// ERR: <type>::generate - the number of inputs needs to be greater than 0 (set to 1)
			/// ERR: <type>::generate - the number of outputs needs to be greater than 0 (set to 1)
			ARE_EQUAL(fsm->getNumberOfStates(), state_t(1), "The number of states is not correct.");
			ARE_EQUAL(fsm->getNumberOfInputs(), input_t(1), "The number of inputs is not correct.");
			ARE_EQUAL(fsm->getNumberOfOutputs(), output_t(1), "The number of outputs is not correct.");
			tSaveLoad();

			fsm->generate(5, 3, 2);
			ARE_EQUAL(fsm->getNumberOfStates(), state_t(5), "The number of states is not correct.");
			ARE_EQUAL(fsm->getNumberOfInputs(), input_t(3), "The number of inputs is not correct.");
			ARE_EQUAL(fsm->getNumberOfOutputs(), output_t(2), "The number of outputs is not correct.");
			tSaveLoad();

			fsm->removeTransition(0, 0);
			fsm->removeTransition(1, 1);
			fsm->removeTransition(2, 2);
			/// 3 transitions * 2 machines = 6 ERRs if fsm->isOutputTransition()
			/// <type>::getOutput - there is no such transition
			fsm->removeState(3);
			/// if fsm->isOutputTransition() && there was a transition to state 3, then 2 ERRs:
			/// <type>::getOutput - there is no such transition
			tSaveLoad();
		}
Example #2
0
		/// includes tests for getNumberOfStates/Inputs/Outputs()
		/// and confirms create(), removeTransition()
		void tCreateSaveLoad() {
			DEBUG_MSG("Create: %s", machineTypeNames[fsm->getType()]);
			fsm->create(0, 0, 0);// = create(1,0,0) is minimum
			/// ERR: <type>::create - the number of states needs to be greater than 0 (set to 1)
			ARE_EQUAL(fsm->getNumberOfStates(), state_t(1), "The number of states is not correct.");
			ARE_EQUAL(fsm->getNumberOfInputs(), input_t(0), "The number of inputs is not correct.");
			ARE_EQUAL(fsm->getNumberOfOutputs(), output_t(0), "The number of outputs is not correct.");
			tSaveLoad();

			fsm->create(5, 3, 2);
			ARE_EQUAL(fsm->getNumberOfStates(), state_t(5), "The number of states is not correct.");
			ARE_EQUAL(fsm->getNumberOfInputs(), input_t(3), "The number of inputs is not correct.");
			ARE_EQUAL(fsm->getNumberOfOutputs(), output_t(2), "The number of outputs is not correct.");
			/// 5 states * 3 inputs * 2 machines = 30 ERRs if fsm->isOutputTransition()
			/// <type>::getOutput - there is no such transition
			tSaveLoad();

			fsm->setTransition(0, 0, 0);
			fsm->setTransition(0, 1, 1);
			fsm->setTransition(0, 2, 2);
			fsm->setTransition(1, 0, 3);
			fsm->setTransition(2, 1, 4);
			fsm->setTransition(3, 2, 0);
			fsm->setTransition(4, 0, 2);
			/// (5 states * 3 inputs - 7 transitions) * 2 machines = 16 ERRs if fsm->isOutputTransition()
			/// <type>::getOutput - there is no such transition
			tSaveLoad();
		}
Example #3
0
state_t graph_t<NodeCount>::next(const state_t & state, sigma_t sigma) const {
    //edge_t backward_edge = state.e == GRAPH_0 ? switch_setting(sigma, state) : GRAPH_0;
    
    /* Find the vertex connected to the edge */
    const typename graph_t<NodeCount>::connection_t *connection = std::find_if(m_graph[state.v], m_graph[state.v] + NodeCount, vertex_contains_edge<NodeCount>(state.e));
    
    unsigned int vertex = connection - m_graph[state.v];
    
    /* Find the edge connecting the newly found vertex to our state vertex */
    edge_t backward_edge = m_graph[vertex][state.v][std::find(connection->begin(), connection->end(), state.e) - connection->begin()];
    
    if (backward_edge == GRAPH_0)
        return state_t(vertex, switch_setting(sigma, state_t(vertex, 0)));
    else
        return state_t(vertex, GRAPH_0);
}
Example #4
0
		/// includes tests for getNumberOfStates/Inputs/Outputs(), getType(),
		///		isReduced(), isOutputState/Transition(), getStates(), addState(), removeState()
		///		save(), load()
		/// confirms getOutput(), getNextState()
		void tSaveLoad() {
			string path = DATA_PATH;
			path += "tmp/";
			string filename = fsm->save(path);
			ARE_EQUAL(!filename.empty(), true, "This %s cannot be saved into path '%s'.",
				machineTypeNames[fsm->getType()], path.c_str());
			ARE_EQUAL(fsm2->load(filename), true, "File '%s' cannot be loaded.", filename.c_str());
			DEBUG_MSG(filename.c_str());
			
			ARE_EQUAL(fsm->getType(), fsm2->getType(), "Types of machines are not equal.");
			ARE_EQUAL(fsm->getNumberOfStates(), fsm2->getNumberOfStates(), "The numbers of states are not equal.");
			ARE_EQUAL(fsm->getNumberOfInputs(), fsm2->getNumberOfInputs(), "The numbers of inputs are not equal.");
			ARE_EQUAL(fsm->getNumberOfOutputs(), fsm2->getNumberOfOutputs(), "The numbers of outputs are not equal.");
			ARE_EQUAL(fsm->isReduced(), fsm2->isReduced(), "The indicators of minimal form are not equal.");
			ARE_EQUAL(fsm->isOutputState(), fsm2->isOutputState(), "The indicators of state outputs are not equal.");
			ARE_EQUAL(fsm->isOutputTransition(), fsm2->isOutputTransition(), "The indicators of transition outputs are not equal.");
			
			auto states = fsm->getStates();
			ARE_EQUAL(fsm->getNumberOfStates(), state_t(states.size()), "The numbers of states are not equal.");
			auto states2 = fsm2->getStates();
			ARE_EQUAL(states == states2, true, "The sets of states are not equal.");
			ARE_EQUAL((find(states.begin(), states.end(), 0) != states.end()), true, "The initial state is missing.");

			for (state_t& state : states) {
				if (fsm->isOutputState()) {
					ARE_EQUAL(fsm->getOutput(state, STOUT_INPUT), fsm2->getOutput(state, STOUT_INPUT), 
						"The outputs of state %d are different.", state);
				}
				for (input_t i = 0; i < fsm->getNumberOfInputs(); i++) {
					state_t nextState = fsm->getNextState(state, i);
					//DEBUG_MSG("%d", nextState);
					if (fsm->isOutputTransition()) {
						output_t output = fsm->getOutput(state, i);
						ARE_EQUAL(output, fsm2->getOutput(state, i),
							"The outputs on input %d from state %d are different.", i, state);
						if (nextState == NULL_STATE) {
							ARE_EQUAL(WRONG_OUTPUT, output,
								"There is no transition on input %d from state %d but output %d is set.",
								i, state, output);
						}
					}
					ARE_EQUAL(nextState, fsm2->getNextState(state, i),
						"The next states on input %d from state %d are different.", i, state);
					ARE_EQUAL(nextState != WRONG_STATE, true, 
						"The next state on input %d from state %d is wrong.", i, state);
					if (nextState != NULL_STATE) {
						ARE_EQUAL((find(states.begin(), states.end(), nextState) != states.end()),
							true, "The next state is wrong.");
					}
				}
			}
			auto newState = fsm->addState();
			//DEBUG_MSG("%d", newState);
			ARE_EQUAL(fsm->getNumberOfStates(), fsm2->getNumberOfStates() + 1, "The numbers of states are to be different by one.");
			ARE_EQUAL(newState, fsm2->addState(), "IDs of new states are not equal.");
			ARE_EQUAL(fsm->getNumberOfStates(), fsm2->getNumberOfStates(), "The numbers of states are not equal.");
			fsm->removeState(newState);
			ARE_EQUAL(fsm->getNumberOfStates(), fsm2->getNumberOfStates() - 1, "The numbers of states are to be different by one.");
		}
Example #5
0
int main(int argc , char ** argv){
    int * state = new int[36];
    for(int i = 1; i < argc; i++){
        state[i-1] = atoi(argv[i]);
    }
    state_t stat = state_t();
    stat.set_state(state);
    stat.set_player(false);
    state_t best = stat.bestNextMove();
    best.print(std::cout,10);
}
void ext_model::update( double time )
{
    view::update(time);

    double const fms_calc_step = cfg().model_params.msys_step;
    if(pilot_impl_)
    {
        double dt = last_time_ ? time - *last_time_ : 0.;

#if 0
        if (!cg::eq_zero(dt))
        {
            geo_base_3 prev_pos = pilot_impl_->state().dyn_state.pos;
            if (dt > 0)
            {
                size_t steps = cg::floor(dt / fms_calc_step + fms_calc_step * .1);
                fms::pilot_simulation_ptr pilot_sim(pilot_impl_);
                for (size_t i = 0; i < steps; ++i)
                {
                    pilot_sim->update(fms_calc_step);
                }
            }

            point_3 offset = prev_pos(pilot_impl_->state().dyn_state.pos);

            double course = pilot_impl_->state().dyn_state.course;
            double roll = pilot_impl_->roll();

            cpr orien(course, polar_point_3(offset).pitch, roll);
            
            set_state(state_t(pilot_impl_->state(), orien.pitch, orien.roll, state_.version + 1), false);

            if (pilot_impl_->instrument() && pilot_impl_->instrument_ended())
            {
                fms::plan_t plan;
                if (get_plan().size() > 1)
                {
                    auto tmp_plan = fms::plan_t(get_plan().begin()+1, get_plan().end());
                    std::swap(plan, tmp_plan);
                }
                else if (pilot_impl_->instrument()->kind() == fms::INSTRUMENT_APPROACH && pilot_impl_->state().dyn_state.cfg != fms::CFG_GD)
                {
                    plan.push_back(fms::create_direction_instrument(boost::none, get_instruments_env())) ;
                }

                set_plan(plan);
            }
        }
#endif

    }

    last_time_ = time;
}
Example #7
0
	inline void error_report(lua_State *state, bool suc, int type, int idx, const char *msg)
	{
		if( suc )
			return;

		std::ostringstream os;
		os << "lua parameter error: " << std::endl
			<< "index [" << idx << "]" << std::endl
			<< "real type [" << ::lua_typename(state, ::lua_type(state, idx)) << "]" << std::endl
			<< "expected type [" << ::lua_typename(state, type) << "]" << std::endl
			<< "information [" << msg << "]" << std::endl;

		throw parameter_error_t(state_t(state), std::move(os.str()));
	}
Example #8
0
    uint64_t next()
    {
	uint64_t cur_word, cur_m;
	uint8_t cur_depth;
	
	assert(m_stack.size());
	boost::tie(cur_word, cur_m, cur_depth) = m_stack.back();
	m_stack.pop_back();
	
	while (cur_depth < m_bits) {
	    boost::random::uniform_int_distribution<uint64_t> dist(0, cur_m);
	    uint64_t left_m = dist(m_gen);
	    uint64_t right_m = cur_m - left_m;
	    
	    // push left and right children, if present
	    if (right_m > 0) {
		m_stack.push_back(state_t(cur_word | (uint64_t(1) << (m_bits - cur_depth - 1)),
					  right_m, cur_depth + 1));
	    }
	    if (left_m > 0) {
		m_stack.push_back(state_t(cur_word, left_m, cur_depth + 1));
		
	    }

	    // pop next child in visit
	    boost::tie(cur_word, cur_m, cur_depth) = m_stack.back();
	    m_stack.pop_back();
	}

	if (cur_m > 1) {
	    // push back the current leaf, with cur_m decreased by one
	    m_stack.push_back(state_t(cur_word, cur_m - 1, cur_depth));
	}

	return cur_word;
    }
Example #9
0
void sample_sigmas(const graph_t<NodeCount> & graph, const ObservationIteratorT & observation_begin,
                   const ObservationIteratorT & observation_end,
                   OutputIteratorT & output_it, size_t num_samples, size_t burn_in, size_t sampling_interval) {
    sampler<sigma_t, probability_t, OutputIteratorT> s(output_it, burn_in, sampling_interval);
    Q<NodeCount> q;
    
    for(size_t i = 0; i < NodeCount; ++i) {
        for(size_t j = 0; j < num_edges; ++j) {
            sigma_t sigma(random_sigma<NodeCount>());
            D_over_stop_state<NodeCount, ObservationIteratorT> d(graph, state_t(i, edges[j]), observation_begin, observation_end);
            
            // <sigma_t, Q<NodeCount>, D_over_stop_state<NodeCount, ObservationIteratorT>, sampler<sigma_t, probability_t, OutputIteratorT> >
            metropolis_hastings(sigma, q, d, s, num_samples / (NodeCount * num_edges));
        }
    }
}
Example #10
0
		static int handler(lua_State *state)
		{
			std::uint32_t len = 0;
			const char *msg = ::lua_tolstring(state, -1, &len);

			std::string error_msg;
			if( len == 0 )
				error_msg = "unknown error";
			else
				error_msg.append(msg, len);
	
			std::printf(error_msg.c_str());
			std::printf("\n");
			stack_trace(state, std::cerr);
			assert(0 && "lua has fatal error");
			throw fatal_error_t(state_t(state), std::move(error_msg));

			return 0;
		}
Example #11
0
state_t graph_t<NodeCount>::previous(const state_t & state, sigma_t sigma) const {
    edge_t backward_edge = state.e == GRAPH_0 ? switch_setting(sigma, state) : GRAPH_0;
    
    /* Find the vertex connected to the edge backward_edge */
    const typename graph_t<NodeCount>::connection_t *connection = std::find_if(m_graph[state.v], m_graph[state.v] + NodeCount, vertex_contains_edge<NodeCount>(backward_edge));
    
    /*const typename graph_t<NodeCount>::connection_t *connection;
    unsigned int vertex;
    
    for(size_t i = 0; i < NodeCount; ++i) {
        if (m_graph[state.v][i].find(backward_edge) != std::string::npos) {
            connection = &m_graph[state.v][i];
            vertex = i;
            break;
        }
    }*/
    
    unsigned int vertex = connection - m_graph[state.v];
    
    /* Find the edge connecting the newly found vertex to our state vertex */
    return state_t(vertex, m_graph[vertex][state.v][std::find(connection->begin(), connection->end(), backward_edge) - connection->begin()]);
}
void model::update(double time)
{
    view::update(time);
	
	if(start_)
	{
		start_();
		start_.clear();
	}

	double dt = time - (last_update_ ? *last_update_ : 0);
    if (!cg::eq_zero(dt))
    {

        update_model(time, dt);
#if 0
        if (!manual_controls_)
#endif
        sync_phys(dt);
#if 0
        else
        {
            cg::geo_base_3 base = phys_->get_base(*phys_zone_); 
            decart_position cur_pos = phys_vehicle_->get_position();
            geo_position cur_glb_pos(cur_pos, base);
            set_state(state_t(cur_glb_pos.pos, cur_pos.orien.get_course(), 0)); 
        }
#endif


        sync_nodes_manager(dt);

    }

    last_update_ = time;

}
Example #13
0
void trace_plot(const graph_t<NodeCount> & graph, const ObservationIteratorT & observation_begin,
                const ObservationIteratorT & observation_end,
                OutputIteratorT & output_it, size_t num_samples) {
    Q<NodeCount> q;
    
    for(size_t i = 0; i < NodeCount; ++i) {
        for(size_t j = 0; j < num_edges; ++j) {
            D_over_stop_state<NodeCount, ObservationIteratorT> d(graph, state_t(i, edges[j]), observation_begin, observation_end);
            std::vector< probability_t > weighted_samples(num_samples / (NodeCount * num_edges), probability_t(0));
            
            for(size_t k = 0; k < smooth_samples; ++k) {
                sigma_t sigma(random_sigma<NodeCount>());
                
                // <sigma_t, Q<NodeCount>, D_over_stop_state<NodeCount, ObservationIteratorT>, sampler<sigma_t, probability_t, OutputIteratorT> >
                
                std::vector< std::pair<sigma_t, probability_t> > samples;
                std::back_insert_iterator< std::vector< std::pair<sigma_t, probability_t> > > inserter(samples);

                sampler<sigma_t, probability_t, std::back_insert_iterator< std::vector< std::pair<sigma_t, probability_t> > > > s(inserter, 0, 1);
                
                metropolis_hastings(sigma, q, d, s, num_samples / (NodeCount * num_edges));
                
                //std::cerr << "asdf4, state: " << i << ", " << edges[j] << ", num_samples: " << samples.size() << " of " << (num_samples / (NodeCount * num_edges)) << std::endl;
                
                for(size_t i = 0; i < samples.size(); ++i)
                    weighted_samples[i] += samples[i].second;
            }
            
            for(size_t i = 0; i < weighted_samples.size(); ++i)
                weighted_samples[i] /= smooth_samples;
            
            output_it = weighted_samples;
                
            ++output_it;
        }
    }
}
Example #14
0
/**
 * Tests an obstacle appearing during a trajectory execution
 */
TEST_F(StateMachineControlTest, TrajectoryInterrupt) {

    StateMachineControl *fsm_control = new StateMachineControl(lcm_, "../TrajectoryLibrary/trajtest/full", "tvlqr-action-out", "state-machine-state", "altitude-reset", false);
    //fsm_control->GetFsmContext()->setDebugFlag(true);

    SubscribeLcmChannels(fsm_control);

    ForceAutonomousMode();

    float altitude = 100;

    // send an obstacle to get it to transition to a new time

    mav::pose_t msg = GetDefaultPoseMsg();

    lcm_->publish(pose_channel_, &msg);
    ProcessAllLcmMessages(fsm_control);

    float point[3] = { 24, 0, 0+altitude };
    SendStereoPointTriple(point);
    ProcessAllLcmMessages(fsm_control);

    lcm_->publish(pose_channel_, &msg);
    ProcessAllLcmMessages(fsm_control);


    // ensure that we have changed trajectories
    EXPECT_EQ_ARM(fsm_control->GetCurrentTrajectory().GetTrajectoryNumber(), 2); // from matlab

    Trajectory running_traj = fsm_control->GetCurrentTrajectory();

    // wait for that trajectory to time out
    int64_t t_start = GetTimestampNow();
    double t = 0;
    while (t < 1.0) {
        usleep(7142); // 1/140 of a second

        msg.utime = GetTimestampNow();

        t = (msg.utime - t_start) / 1000000.0;

        Eigen::VectorXd state_t = running_traj.GetState(t);

        msg.pos[0] = state_t(0);
        msg.pos[1] = state_t(1);
        msg.pos[2] = state_t(2) + altitude;

        msg.vel[0] = state_t(6);
        msg.vel[1] = state_t(7);
        msg.vel[2] = state_t(8);

        double rpy[3];
        rpy[0] = state_t(3);
        rpy[1] = state_t(4);
        rpy[2] = state_t(5);

        double quat[4];
        bot_roll_pitch_yaw_to_quat(rpy, quat);

        msg.orientation[0] = quat[0];
        msg.orientation[1] = quat[1];
        msg.orientation[2] = quat[2];
        msg.orientation[3] = quat[3];

        msg.rotation_rate[0] = state_t(9);
        msg.rotation_rate[1] = state_t(10);
        msg.rotation_rate[2] = state_t(11);


        lcm_->publish(pose_channel_, &msg);
        ProcessAllLcmMessages(fsm_control);
    }

    // now add a new obstacle right in front!
    std::cout << "NEW POINT" << std::endl;
    lcm_->publish(pose_channel_, &msg);
    ProcessAllLcmMessages(fsm_control);

    float point2[3] = { 18, 12, 0+altitude };
    SendStereoPointTriple(point2);
    ProcessAllLcmMessages(fsm_control);

    lcm_->publish(pose_channel_, &msg);
    ProcessAllLcmMessages(fsm_control);

    fsm_control->GetOctomap()->Draw(lcm_->getUnderlyingLCM());
    BotTrans body_to_local;
    bot_frames_get_trans(bot_frames_, "body", "local", &body_to_local);
    fsm_control->GetTrajectoryLibrary()->Draw(lcm_->getUnderlyingLCM(), &body_to_local);

    fsm_control->GetTrajectoryLibrary()->Draw(lcm_->getUnderlyingLCM(), &body_to_local);

    bot_lcmgl_t *lcmgl = bot_lcmgl_init(lcm_->getUnderlyingLCM(), "Trjaectory");
    bot_lcmgl_color3f(lcmgl, 0, 1, 0);
    fsm_control->GetCurrentTrajectory().Draw(lcmgl ,&body_to_local);
    bot_lcmgl_switch_buffer(lcmgl);
    bot_lcmgl_destroy(lcmgl);


    EXPECT_EQ_ARM(fsm_control->GetCurrentTrajectory().GetTrajectoryNumber(), 3); // from matlab

    delete fsm_control;

    UnsubscribeLcmChannels();
}
Example #15
0
int main(int argc, const char **argv) {
    srand(time(NULL));
    const size_t num_samples = 10000, burn_in = 5, sampling_interval = 5;
    
    const size_t NodeCount = 12;
    
    typename graph_t<NodeCount>::connection_t map[][NodeCount] = /*{
        { "", "L", "0", "R" },
        { "0","", "R", "L" },
        { "0", "R","", "L" },
        { "R", "0", "L","" },
    };*/
    {
        {"", "0", "R","","","","","","", "L","","" },
        { "0","", "L", "R","","","","","","","","" },
        { "0", "L","", "R","","","","","","","","" },
        {"", "L", "R","","","","","","","","", "0" },
        {"","","","","", "R","","", "L","", "0","" },
        {"","","","", "R","","", "L", "0","","","" },
        {"","","","","","","", "R","","", "L", "0" },
        {"","","","","", "0", "R","","","", "L","" },
        {"","","","", "R", "L","","","", "0","","" },
        { "0","","","","","","","", "L","","", "R" },
        {"","","","", "R","", "0", "L","","","","" },
        {"","","", "L","","", "R","","", "0","","" },
    };
    
    graph_t<NodeCount> graph;
    graph.parse(map);
    
    const size_t observation_length = 100;
    
    typedef std::vector<edge_t> observation_sequence_t;

    observation_sequence_t observation;
    const state_t state(generate_observation_sequence<NodeCount>(graph, observation_length, std::back_insert_iterator<observation_sequence_t>(observation)));
    
    std::cerr << "observation sequence:";
    std::copy(observation.begin(), observation.end(), std::ostream_iterator<edge_t>(std::cerr, ", "));
    std::cerr << "stop state is: " << state << std::endl;

    //std::cerr << "previous:" << graph.previous(state_t(0, '0'), 0) << std::endl;
    
    typedef std::vector< std::pair<sigma_t, probability_t> > sigma_sequence_t;
    
    sigma_sequence_t sigmas;
    
    std::back_insert_iterator<sigma_sequence_t> inserter(sigmas);
    sample_sigmas<NodeCount>(graph, observation.begin(), observation.end(), inserter, num_samples, burn_in, sampling_interval);
    
    /*std::cerr << "sigmas:" << std::endl;
    probability_t p(0);
    for(sigma_sequence_t::iterator it = sigmas.begin(); it != sigmas.end(); ++it) {
        std::cerr << "(" << it->first << ", " << it->second << "), ";
        p += it->second;
    }*/
    
    //std::cerr << "state_probability: " << state_probability<NodeCount>(state, graph, observation.begin(), observation.end(), sigmas.begin(), sigmas.end()) << std::endl;
    
    std::vector< std::pair<state_t, probability_t> > sorted_states;
    
    probability_t total_prob(0);
    for(size_t i = 0; i < NodeCount; ++i) {
        for(size_t j = 0; j < num_edges; ++j) {
            probability_t prob = state_probability<NodeCount>(state_t(i, edges[j]), graph, observation.begin(), observation.end(), sigmas.begin(), sigmas.end());
            //std::cerr << "state_probability: " << prob << " for stop_state: " << state_t(i, edges[j]) << std::endl;
            total_prob += prob;
            
            sorted_states.push_back(std::make_pair(state_t(i, edges[j]), prob));
        }
    }
    
    std::cerr << "total_prob: " << total_prob << std::endl;
    
    std::sort(sorted_states.begin(), sorted_states.end(), state_probability_sort_comp());
    
    for(std::vector< std::pair<state_t, probability_t> >::const_iterator it = sorted_states.begin(); it != sorted_states.end(); ++it) {
        std::cerr << "probability: " << it->second << " for state: " << it->first;
        
        if (it->first.v == state.v && it->first.e == state.e)
            std::cerr << " [ answer ]";
        std::cerr << std::endl;
    }
    
    /*
     * trace plot
     */
                
    std::vector<std::vector< probability_t > > traces;
    std::back_insert_iterator< std::vector<std::vector< probability_t > > > traces_inserter(traces);
    trace_plot(graph, observation.begin(), observation.end(), traces_inserter, num_samples);
    
    //std::cerr << "plot done" << std::endl;
    
    std::fstream file("plot.py", std::ios_base::out);
    
    /*
    pl.semilogy([ prob / length for prob in p ])
        #break
        
    pl.xlabel('interval')
    pl.ylabel('log(probability) + k')
    pl.title('Convergence plot')
    pl.grid(True)
    pl.savefig(filename, bbox_inches = 0)
    
    pl.show()
    */
    
    file << "import pylab as pl" << std::endl << "pl.xlabel('interval')\npl.ylabel('log(probability) + k')\npl.title('Convergence plot')\npl.grid(True)" << std::endl;
    
    for(std::vector<std::vector< probability_t > >::const_iterator it = traces.begin(); it != traces.end(); ++it) {
        file << "pl.semilogy([ ";
        
        for(std::vector< probability_t >::const_iterator jt = it->begin(); jt != it->end() -1; ++jt)
            file << *jt << ", ";
        
        file << *(it->end() - 1) << " ])" << std::endl;
    }
    
    file << "pl.show()" << std::endl;
    
    file.close();
}
Example #16
0
    monotone_generator(uint64_t m, uint8_t bits, unsigned int seed)
	: m_gen(seed)
        , m_bits(bits)
    {
	m_stack.push_back(state_t(0, m, 0));
    }
Example #17
0
 inline D_over_stop_state(const graph_t<NodeCount> & graph,
                          const state_t & start_state,
                          const ObservationIteratorT & observation_begin,
                          const ObservationIteratorT & observation_end) : D<NodeCount, ObservationIteratorT>(graph, state_t(), observation_begin, observation_end),
                                                                          m_graph(graph), m_start_state(start_state), m_observation_begin(observation_begin), m_observation_end(observation_end) {
     
 }
Example #18
0
 inline observation_probability(const graph_t<NodeCount> & graph,
                                const ObservationIteratorT & observation_begin,
                                const ObservationIteratorT & observation_end) : D<NodeCount, ObservationIteratorT>(graph, state_t(), observation_begin, observation_end) {
     
 }