static CharT decode_octal (state &state_) { std::size_t accumulator_ = 0; CharT ch_ = *state_._curr; unsigned short count_ = 3; bool eos_ = false; for (;;) { accumulator_ *= 8; accumulator_ += ch_ - '0'; --count_; state_.increment (); eos_ = state_.eos (); if (!count_ || eos_) break; ch_ = *state_._curr; // Don't consume invalid chars! if (ch_ < '0' || ch_ > '7') { break; } } return static_cast<CharT> (accumulator_); }
bool process(state* astate, queue<state*>& bfsq) { if(astate->clocks == ten9) { return print(astate); } for(int i=0; i<9; i++) { newstate.set(astate); newstate.inc(config[i]); //cout<<"trying state: "<<newstates[i].getnum()<<", foundsz="<<answers.size()<<endl; if(visited.find(newstate.clocks) == visited.end()) { state *ns = new state(); ns->clocks = newstate.clocks; ns->prevop = i+1; ns->prevstate = astate; bfsq.push(ns); visited[ns->clocks] = true; nobj++; } } return true; }
void statement::generate_nested(state & state, ostream & stream) { state.increase_indentation(); state.new_line(stream); generate(state, stream); state.decrease_indentation(); }
int main() { ifstream in("/home/joshua/Downloads/s4.4.in"); while(1) { done=0; int N; in>>N; if(!N) break; for(int i=0;i<32609;i++) MHASH[i].clear(); _.clear(); m.clear(); int X; for(int i=0;i<N;i++) { place p,v; in>>X; p.push_back(X); _.push_back(p); v.push_back(i+1); m.push_back(v); } superhash=hash(m); recurse(_,0); while(Q.size()) { state l=Q.front().first; int m=Q.front().second; Q.pop_front(); recurse(l,m); } bool ok=0; for(set<gstate>::iterator it=MHASH[superhash].begin();it!=MHASH[superhash].end();++it) { if((*it).first==m) { ok=1; cout<< ((*it).second)<<endl; break; } } if(!ok) cout<<"IMPOSSIBLE"<<endl; } }
bool table::need_calculate(const state & state) const { return this->street != state.get_street() || this->get_dealer_pos() != state.get_dealer_pos() || this->get_my_player().get_hand() != state.get_pocket() || this->active_players_count() != state.get_active_players_count(); }
/// Opens a library /// /// \param s The Lua state. /// \param name The name of the module to create. /// \param members The list of member functions to add to the module. void lutok::registerLib(state& s, const std::map< std::string, cxx_function >& members){ assert(s.is_table()); for (std::map< std::string, cxx_function >::const_iterator iter = members.begin(); iter != members.end(); iter++) { s.push_string((*iter).first); s.push_cxx_function((*iter).second); s.set_table(-3); } }
static typename lutok::LObject<T>::Index lutok::LObject<T>::push(state& s, T* instance, bool gc) { if (!instance) { s.push_nil(); return 0; } luaL_getmetatable(s._pimpl->lua_state, T::s_lunaClassName); if (s.is_nil()) { luaL_error(s._pimpl->lua_state, "[Luna::%s] Class %s has not been commited!", __func__, T::s_lunaClassName); return 0; } lutok::LObject<T>::Index metatable = s.get_top(); subtable(s, metatable, "userdata", "v"); lutok::LObject<T>::Userdata * userdata = allocUserdata(s, metatable, instance); if (userdata) { userdata->pT = instance; s.push_value(metatable); s.set_metatable(); if (!gc) { lua_checkstack(s._pimpl->lua_state, 3); subtable(s, metatable, "unmanaged", "k"); s.push_value(-2); s.push_boolean(1); s.set_table(); s.pop(1); } } lua_replace(s._pimpl->lua_state, metatable); lua_settop(s._pimpl->lua_state, metatable); return metatable; }
void complex_statement::generate_nested(state & state, ostream & stream) { state.new_line(stream); stream << "{"; state.increase_indentation(); state.new_line(stream); generate(state, stream); state.decrease_indentation(); state.new_line(stream); stream << "}"; }
void input() { G.assign(2 * x, vector<int>()), s.assign(x, ""), t.assign(x, ""); rep(i, y) { int p, q; char P, Q; cin >> p >> P >> q >> Q; int a = P == 'W' ? p : p + x; int b = Q == 'W' ? q : q + x; G[a].pb(b), G[b].pb(a); }
bool simulation::match(const state &left, const state &right) { assert(left.size() == right.size()); for (size_t i = 0; i < left.size(); i++) { if (!is_variable(left[i]) && !is_variable(right[i]) && left[i] != right[i]) { return false; } } return true; }
/** * @brief setter * Der aktuelle Zustand wird geaendert. Das Signal stateChanged(newState.getID()) wird ausgeloest. * @param newState neuer Zustand * @return void */ void automaton::setState(state newState){ currentState = newState; emit stateChanged(newState.getId()); // Testfunktion QMessageBox msgBox; msgBox.setText("Die Id des States auf den zu setzen ist, ist: "+ QString::number(newState.getId())); msgBox.exec(); msgBox.setText("Die Id des neuen States ist: "+ QString::number(currentState.getId())); msgBox.exec(); }
/** FUNCTION: overload == operator DESCRIPTION: Overloads the == operator so that it can be used to test wheather or not 'this' state is equal to otherState. RETURN bool - True if in fact 'this' state is equal to otherState */ bool state::operator== (const state& otherState) const{ if(otherState.boardMemoryAllocated == false) return false; if(this->getBoard()[0][0] != otherState.getBoard()[0][0])return false; if(this->getBoard()[0][1] != otherState.getBoard()[0][1])return false; if(this->getBoard()[0][2] != otherState.getBoard()[0][2])return false; if(this->getBoard()[1][0] != otherState.getBoard()[1][0])return false; if(this->getBoard()[1][1] != otherState.getBoard()[1][1])return false; if(this->getBoard()[1][2] != otherState.getBoard()[1][2])return false; if(this->getBoard()[2][0] != otherState.getBoard()[2][0])return false; if(this->getBoard()[2][1] != otherState.getBoard()[2][1])return false; if(this->getBoard()[2][2] != otherState.getBoard()[2][2])return false; return true; }
static int lutok::LObject<T>::gcT(state& s) { if (luaL_getmetafield(s._pimpl->lua_state, 1, "unmanaged")) { s.push_value(1); s.get_table(); if (!s.is_nil()) { return 0; } } Userdata* ud = s.to_userdata<UserData>(1); T* obj = ud->pT; delete obj; return 0; }
/// Creates a module: i.e. a table with a set of methods in it. /// /// \param s The Lua state. /// \param name The name of the module to create. /// \param members The list of member functions to add to the module. void lutok::create_module(state& s, const std::string& name, const std::map< std::string, cxx_function >& members) { stack_cleaner cleaner(s); s.new_table(); for (std::map< std::string, cxx_function >::const_iterator iter = members.begin(); iter != members.end(); iter++) { s.push_string((*iter).first); s.push_cxx_function((*iter).second); s.set_table(-3); } s.set_global(name); }
action2ValuePair min_Value(int clr,int alpha, int beta){ action2 a2; if(terminal_Test()){ double util=currentState->utility(count); int d=currentState->depth; action2ValuePair a2v(chance[d]*util,a2); return a2v; } double v=10000; vector<colorNode> cn=generateColors(clr); vector<action2> actions=chaosActions(cn); int l=actions.size(); for(int i=0;i<l;i++){ nodecount++; action2 a=actions.at(i); chaosMove(a); double val=max_Value(alpha,beta).value; chaosDeMove(a); if(v>val){ v=val; a2=a; } if(v<alpha){ action2ValuePair a2v(v,a2); return a2v; } if(beta>v){ beta=v; } } action2ValuePair a2v(v,a2); return a2v; }
actionValuePair max_Value(double alpha, double beta){ action a2; if(terminal_Test()){ double util=currentState->utility(count); int d=currentState->depth; actionValuePair av(chance[d]*util,a2); return av; } double v=-10000; vector<action> actions=orderActions(); int l=actions.size(); for(int i=0;i<l;i++){ nodecount++; action a=actions.at(i); orderMove(a);//depth++ double val=min_Value(-1,alpha,beta).value; orderDeMove(a);//depth-- if(v<val){ v=val; a2=a; } if(v>beta){ actionValuePair av(v,a2); return av; } if(alpha<v){ alpha=v; } } actionValuePair av(v,a2); return av; }
int bfs(state init) { state u, v; queue<state> Q; map<state, int> R; int f; init = eraseGoal(init); Q.push(init), R[init] = 0; // print(init); if (init.isComplete()) return 0; while (!Q.empty()) { u = Q.front(), Q.pop(); int step = R[u]; // print(u); // printf("step %d\n", step); for (int i = 0; i < 4; i++) { v = rotateMap(u, i, f); v = eraseGoal(v); if (!f || R.count(v)) continue; if (v.isComplete()) return step + 1; R[v] = step + 1; // print(v); Q.push(v); } // puts("--------------"); // getchar(); } return -1; }
double GTPWrapper::countBlack(state bboard){ double ret=0; for(unsigned int i=0;i<(bboard.size()/2);i++) if(bboard[2*i]==0 && bboard[(2*i)+1]==1) ret++; return ret; }
state next_state(const state &s) { auto state_size = s.size(); state ret; ret.reserve(state_size); if (!state_size) { throw std::runtime_error("empty state"); } // trivial case if (state_size == 1) { ret.push_back(false); return ret; } // Left border ret.push_back(s[1] != s[state_size - 1]); for (std::vector<bool>::size_type i = 1; i < state_size - 1; ++i) { ret.push_back(s[i - 1] != s[i + 1]); } // Right border ret.push_back(s[state_size - 2] != s[0]); return ret; }
int hash(state& s) { int l=0; for(int i=0;i<s.size();i++) { l+=primes[i]*hash(s[i]); l%=32609; } return l; }
void PTS::set_frequency_ttls(state& the_state) { // find the frequency informations... // and exchange the phase informations analogout* pts_aout=NULL; /* find a analogout section with suitable id */ state::iterator i=the_state.begin(); while(i!=the_state.end()) { analogout* aout=dynamic_cast<analogout*>(*i); if (aout!=NULL && aout->id==id) { if (pts_aout==NULL) { /* save the informations */ pts_aout=aout; } else { fprintf(stderr, "found another pts decade section, ignoring\n"); delete aout; } /* remove the analog out section */ the_state.erase(i++); } else ++i; } /* state members loop */ /* now, add the ttl information*/ if (pts_aout!=NULL) { phase_add_ttls(the_state, pts_aout->phase); if (pts_aout->frequency!=0) { if (frequency==0) { set_frequency(pts_aout->frequency); } /* different frequencies are forbidden */ else if (frequency!=pts_aout->frequency) { fprintf(stderr, "ignoring frequency %g at analogout %d\n",pts_aout->frequency,id); } } delete pts_aout; } else { /* because we use transparent mode, we have to set phase everywhere */ phase_add_ttls(the_state, phase); } }
static int lutok::LObject<T>::newT(state& s) { lua_remove(s._pimpl->lua_state, 1); T* obj = new T(s); Userdata* ud = s.new_userdata<Userdata>(); ud->pT = obj; luaL_getmetatable(s._pimpl->lua_state, T::s_lunaClassName); s.set_metatable(); return 1; }
double gasinfo::heat_capacity_volume(const state &st) const { double Cv = 0; for (int i = 0; i < nc; i++) { double x = st.rho[i] * Rspecific[i] * beta[i]; Cv += x; } return Cv / st.density(); }
/// Loads and processes a Lua file. /// /// This is a replacement for luaL_dofile but with proper error reporting /// and stack control. /// /// \param s The Lua state. /// \param file The file to load. /// \param nresults The number of results to expect; -1 for any. /// /// \return The number of results left on the stack. /// /// \throw error If there is a problem processing the file. unsigned int lutok::do_file(state& s, const std::string& file, const int nresults) { assert(nresults >= -1); const int height = s.get_top(); stack_cleaner cleaner(s); try { s.load_file(file); s.pcall(0, nresults == -1 ? LUA_MULTRET : nresults, 0); } catch (const lutok::api_error& e) { throw lutok::error("Failed to load Lua file '" + file + "': " + e.what()); } cleaner.forget(); const int actual_results = s.get_top() - height; assert(nresults == -1 || actual_results == nresults); assert(actual_results >= 0); return static_cast< unsigned int >(actual_results); }
/** COPY CONSTRUCTOR: state(const state& obj) DESCRIPTION: Deep copyes obj to this object PARAMS: obj - The obj that this object is about to become. */ state::state(const state& obj){ this->g = obj.g; this->parent = obj.parent; if(obj.boardMemoryAllocated == true){ this->board = new int*[NUM_ROWS_ON_BOARD]; for(int i = 0 ; i < NUM_ROWS_ON_BOARD; i++) { this->board[i] = new int[NUM_COLS_ON_BOARD]; } this->board[0][0] = obj.getBoard()[0][0]; this->board[0][1] = obj.getBoard()[0][1]; this->board[0][2] = obj.getBoard()[0][2]; this->board[1][0] = obj.getBoard()[1][0]; this->board[1][1] = obj.getBoard()[1][1]; this->board[1][2] = obj.getBoard()[1][2]; this->board[2][0] = obj.getBoard()[2][0]; this->board[2][1] = obj.getBoard()[2][1]; this->board[2][2] = obj.getBoard()[2][2]; this->move = obj.move; } }
void PTS::phase_add_ttls(state& the_state, double p) const { unsigned int binary_code=phase_ttl_values(p); std::vector<ttlout>::const_iterator mask=ttl_masks.begin(); while (mask!=ttl_masks.end()) { /* obeye negative logic */ if ((binary_code & 1<<11)==0 ^ negative_logic==0) the_state.push_back(mask->copy_new()); binary_code<<=1; binary_code&=0xFFF; ++mask; } if (binary_code!=0) fprintf(stderr,"Warning! Insufficient phase precision for %f\n",p); }
static CharT decode_control_char (state &state_) { // Skip over 'c' state_.increment (); CharT ch_ = 0; bool eos_ = state_.next (ch_); if (eos_) { // Pointless returning index if at end of string throw runtime_error ("Unexpected end of regex following \\c."); } else { if (ch_ >= 'a' && ch_ <= 'z') { ch_ -= 'a' - 1; } else if (ch_ >= 'A' && ch_ <= 'Z') { ch_ -= 'A' - 1; } else if (ch_ == '@') { // Apparently... ch_ = 0; } else { std::ostringstream ss_; ss_ << "Invalid control char at index " << state_.index () - 1 << '.'; throw runtime_error (ss_.str ().c_str ()); } } return ch_; }
/// update state using a rotation speed (in rad/s) and acceleration (in m/s^2) void update(state & s, double timestep, vector3d const& rotspeed, vector3d const& acc) { double thalf = 0.5*timestep; matrix3d const rhalf = rotation_vec_to_matrix(rotspeed*thalf); matrix3d const ohalf = s.orientation * rhalf; vector3d const racc = ohalf * acc; vector3d const racchp = racc - s.rot_acc_lpf(racc); vector3d const shinc = thalf * racchp; vector3d const shalf = s.speed + shinc; s.location.noalias() += shalf * timestep; s.speed.noalias() = shalf + shinc; s.orientation.noalias() = ohalf * rhalf; }
static void lutok::LObject<T>::weaktable(state& s, const std::string& mode) { s.new_table(); s.push_value(); s.set_metatable(); s.push_literal("__mode"); s.push_string(mode); s.set_table(); }
/// Opens a library /// /// \param s The Lua state. /// \param name The name of the module to create. /// \param members The list of member functions to add to the module. void lutok::registerLib(state& s, const std::string& name, const std::map< std::string, cxx_function >& members, const int nup){ s.findLib(name, members.size(), nup); assert(s.is_table()); for (std::map< std::string, cxx_function >::const_iterator iter = members.begin(); iter != members.end(); iter++) { s.push_string((*iter).first); s.push_cxx_function((*iter).second); s.set_table(-3); } s.pop(nup); }