InfInt karatsubaMult(string x, string y) { InfInt *result = new InfInt(0); int m = makeEqualLength(x, y); if(m == 0) return *result; size_t sz = 0; if( x.length() == 1 || y.length() == 1 ) { result = new InfInt(stoull(x, &sz, 0) * stoull(y, &sz, 0)); return *result; } // m2 + m2Rest = m int m2 = m/2; int m2Rest = m - m2; string xl = x.substr(0, m2); string xr = x.substr(m2, m2Rest); string yl = y.substr(0, m2); string yr = y.substr(m2, m2Rest); InfInt z0 = karatsubaMult(xr, yr); InfInt z1 = karatsubaMult(add(xl, xr), add(yl, yr)); InfInt z2 = karatsubaMult(xl, yl); *result = (z2 * basePower(*INFINTBASE10, 2*m2) + ((z1-z2-z0) * basePower(*INFINTBASE10, m2)) + z0); return *result; }
void Seeker::seekConvertions() { unsigned long long int st, fi, i; std::string::size_type sz = 0; st = stoull(_initNum, &sz, 0); st = st == 0 ? 0 : st; fi = stoull(_finishNum, &sz, 0); fi = fi == 0 ? ipow(_base, _v) : fi; unsigned long long int TOTAL = fi - st; cout << "Begin looking in diapasone: " << st << " to " << fi << endl; double duration, start = clock(); for (i = st; i < fi; i++) { duration = (clock() - start) / (double)CLOCKS_PER_SEC; convertNum2Seq(_sequence, i, _base, _v); if (duration > SHOW_TIME) { cout << "Done: " << (i-st)*100./TOTAL << "%" << endl; start = clock(); writeTEMPNum(i); printSeq(_sequence, _v, "tmp"); } if (isSuiteToBrookRaiserChovla(_sequence, _v)) { if (isTP(_sequence, _v)) { writeSeq2File(); printSeq(_sequence, _v, "GOOD!"); } } } }
int main(){ uint count = 0; uint limit = 10000; for(ullint i = 1; i < limit; i++){ uint iterations = 0; string s1, s2; ullint ly; do{ if(iterations){ s1 = intToString(ly); }else{ s1 = intToString(i); } s2 = s1; reverse(s2.begin(), s2.end()); ly = stoull(s1) + stoull(s2); iterations++; }while(iterations < 30 && !isPalindrome(ly)); if(iterations == 30){ count++; } } cout << count << endl; return 0; }
void Hss::get_autn_info(uint64_t imsi, uint64_t &key, uint64_t &rand_num) { MYSQL_RES *query_res; MYSQL_ROW query_res_row; int i; int num_fields; string query; query_res = NULL; query = "select key_id, rand_num from autn_info where imsi = " + to_string(imsi); cout << "hss_getautninfo:" << query << endl; g_sync.mlock(mysql_client_mux); mysql_client.handle_query(query, &query_res); g_sync.munlock(mysql_client_mux); num_fields = mysql_num_fields(query_res); cout << "hss_getautninfo:" << " fetched" << endl; query_res_row = mysql_fetch_row(query_res); if (query_res_row == 0) { g_utils.handle_type1_error(-1, "mysql_fetch_row error: hss_getautninfo"); } for (i = 0; i < num_fields; i++) { string query_res_field; query_res_field = query_res_row[i]; if (i == 0) { key = stoull(query_res_field); } else { rand_num = stoull(query_res_field); } } mysql_free_result(query_res); }
int CHgzComboBox::GetWindowHexArray(unsigned char * pHex) { CString str; GetWindowText(str); CStringArray arr; hgzExtractSubStrings(arr, str, _T(" +")); //unsigned int *pi = new unsigned int[arr.GetSize()]; int i; int n = 0; for (i = 0; i < arr.GetSize(); i++) { long long x; int j = 0; x = stoull((tstring)arr[i].GetString(), 0, 16); if (x <= 0xFF) j = 1; else if (x <= 0xFFFF) j = 2; else if (x <= 0xFFFFFF) j = 3; else if (x <= 0xFFFFFFFF) j = 4; else if (x <= 0xFFFFFFFFFF) j = 5; else if (x <= 0xFFFFFFFFFFFF) j = 6; else if (x <= 0xFFFFFFFFFFFFFF) j = 7; else if (x <= 0xFFffFFffFFffFFff) j = 8; hgzRevertByteOrder((unsigned char *)&x, j); for (int m = 0; m < j; m++) { pHex[n+m] = ((unsigned char *)&x)[m]; } n += j; } //delete [] pi; return n; }
std::shared_ptr<Response> request_read() { std::shared_ptr<Response> response(new Response()); try { size_t bytes_transferred = boost::asio::read_until(*socket, response->content_buffer, "\r\n\r\n"); size_t num_additional_bytes = response->content_buffer.size() - bytes_transferred; parse_response_header(response, response->content); auto header_it = response->header.find("Content-Length"); if (header_it != response->header.end()) { auto content_length = stoull(header_it->second); if (content_length>num_additional_bytes) { boost::asio::read(*socket, response->content_buffer, boost::asio::transfer_exactly(content_length - num_additional_bytes)); } } else if ((header_it = response->header.find("Transfer-Encoding")) != response->header.end() && header_it->second == "chunked") { boost::asio::streambuf streambuf; std::ostream content(&streambuf); std::streamsize length; std::string buffer; do { size_t bytes_transferred = boost::asio::read_until(*socket, response->content_buffer, "\r\n"); std::string line; getline(response->content, line); bytes_transferred -= line.size() + 1; line.pop_back(); length = stol(line, 0, 16); auto num_additional_bytes = static_cast<std::streamsize>(response->content_buffer.size() - bytes_transferred); if ((2 + length)>num_additional_bytes) { boost::asio::read(*socket, response->content_buffer, boost::asio::transfer_exactly(2 + length - num_additional_bytes)); } buffer.resize(static_cast<size_t>(length)); response->content.read(&buffer[0], length); content.write(&buffer[0], length); //Remove "\r\n" response->content.get(); response->content.get(); } while (length>0); std::ostream response_content_output_stream(&response->content_buffer); response_content_output_stream << content.rdbuf(); } } catch (const std::exception& e) { socket_error = true; throw std::invalid_argument(e.what()); } return response; }
void PosField::parse(const char* start, const char* end) throw (VCFException) { text.assign(start, end); if (!regex_match(text, pos_regex)) { value = numeric_limits<long long unsigned int>::min(); throw VCFException(__FILE__, __FUNCTION__, __LINE__, "Error while parsing POS field."); } value = stoull(text, nullptr, 10); }
void HSS::set_key_id() { query = "select key_id from ue_data where imsi = " + to_string(ue_data.imsi) + " and msisdn = " + to_string(ue_data.msisdn); db_client.perform_query(query.c_str()); query_res = mysql_fetch_row(db_client.result); handle_query_error(); res_row = query_res[0]; ue_data.key_id = stoull(res_row); }
AgentService::AgentService( Context* cct ){ this->cct = cct; flush_op_count = new Count(); int tp_size = stoi(this->cct->config->configValues["agent_threads_num"]); threadpool = new ThreadPool(tp_size); process_tp = new ThreadPool(2); cache_total_size = stoull(this->cct->config->configValues["cache_total_size"]); cache_dirty_ratio_min = stof(this->cct->config->configValues["cache_dirty_ratio_min"]); cache_dirty_ratio_max = stof(this->cct->config->configValues["cache_dirty_ratio_max"]); object_size = stoull(this->cct->config->configValues["object_size"]); cache_flush_interval = stoi(this->cct->config->configValues["cache_flush_interval"]); cache_evict_interval = stoi(this->cct->config->configValues["cache_evict_interval"]); cache_flush_queue_depth = stoi(this->cct->config->configValues["cache_flush_queue_depth"]); cache_ratio_max = stof(this->cct->config->configValues["cache_ratio_max"]); cache_ratio_health = stof(this->cct->config->configValues["cache_ratio_health"]); process_tp->schedule(boost::bind(&AgentService::_process_flush, this)); process_tp->schedule(boost::bind(&AgentService::_process_evict, this)); log_print("AgentService constructed\n"); }
void Response::get_header( const string& name, unsigned long long& value, const unsigned long long default_value ) const { try { value = stoull( get_header( name ) ); } catch ( const invalid_argument& ) { value = default_value; } }
void HSS::set_autn_tokens() { int i; curr_time = time(0); local_time = localtime(&curr_time); curr_sec = local_time->tm_sec; query = "select * from ue_autn where autn like '%" + to_string(curr_sec) + "'"; db_client.perform_query(query.c_str()); num_fields = mysql_num_fields(db_client.result); query_res = mysql_fetch_row(db_client.result); handle_query_error(); for (i = 0; i < num_fields; i++) { res_row = query_res[i]; if (i == 0) { ue_data.autn_num = stoull(res_row); } else { ue_data.rand_num = stoull(res_row); } } }
sai_status_t internal_redis_get_stats_process( _In_ sai_object_type_t object_type, _In_ uint32_t count, _Out_ uint64_t *counter_list, _In_ swss::KeyOpFieldsValuesTuple &kco) { SWSS_LOG_ENTER(); // key: sai_status // field: stat_id // value: stat_value const auto &key = kfvKey(kco); const auto &values = kfvFieldsValues(kco); auto str_sai_status = key; sai_status_t status; sai_deserialize_status(str_sai_status, status); if (status == SAI_STATUS_SUCCESS) { uint32_t i = 0; for (const auto &v : values) { if (i >= count) { SWSS_LOG_ERROR("Received more values than expected"); status = SAI_STATUS_FAILURE; break; } uint64_t value = 0; value = stoull(fvValue(v)); counter_list[i] = value; i++; } } return status; }
int getLuckyRemainder(string X) { uint64_t totalSetCnt = pow(2, X.size()); uint64_t result = 0; for(int i = 0; i < (int)totalSetCnt; ++i) { string powsetBits = bitset<50>(i).to_string(); string generated; int startJ = 50 - X.size(); for(int j = 50 - startJ; j < 50; ++j ) { if(powsetBits[j] == '1') { generated += X[j - startJ]; } } if(!generated.empty()) { result += (stoull(generated)); } } return (int)(result % 9); }
int main(int argc, char *argv[]){ int status = 0; struct sigaction act; pthread_t conn_thread, d_thread, p_thread, n_thread; enum conn_type d = CONN_DRIVER, p = CONN_PREV, n = CONN_NEXT; bool create = false; char *path = NULL, *next = NULL, *prev = NULL; unsigned long long int size = -1; int sig; act.sa_handler = handleExit; sigemptyset(&act.sa_mask); sigaddset(&act.sa_mask, SIGINT); sigaddset(&act.sa_mask, SIGTERM); sigaddset(&act.sa_mask, SIGQUIT); sigaddset(&act.sa_mask, SIGABRT); act.sa_flags = 0; sigaction(SIGINT, &act, NULL); sigaction(SIGTERM, &act, NULL); sigaction(SIGQUIT, &act, NULL); sigaction(SIGABRT, &act, NULL); if(argc < 3){ printf("Usage: command [flags]\n"); printf("-c PATH\tcreate lsvd_disk with pathname PATH\n"); printf("-o PATH\topen existing lsvd_disk with pathname PATH\n"); printf("-p NAME\tconnect replica to upstream host with NAME\n"); printf("-n NAME\tconnect replica to downstream host with NAME\n"); printf("-s SIZE\twhen -c used, initialize lsvd_disk with size SIZE Megabytes\n"); exit(1); } rmgr = new ReplicaManager(); cmgr = new ConnectionManager(); for (int i = 1; i < argc; i++){ if (argv[i][0] != '-'){ printf("Invalid flag\n"); } switch(argv[i][1]){ case 'c': if (i+1 < argc && path == NULL){ create = true; printf("Path: %s\n", argv[i+1]); path = argv[i+1]; i++; } break; case 'o': if (i+1 < argc && path == NULL){ create = false; printf("Path: %s\n", argv[i+1]); path = argv[i+1]; i++; } break; case 'p': if (i+1 < argc && prev == NULL){ printf("Previous name : %s\n", argv[i+1]); prev = argv[i+1]; cmgr->update(CONN_PREV, prev); cmgr->connect(CONN_PREV); i++; } break; case 'n': if (i+1 < argc && next == NULL){ printf("Next name : %s\n"); next = argv[i+1]; cmgr->update(CONN_NEXT, next); i++; } break; case 's': if (i+1 < argc && size == -1){ std::string size_str(argv[i+1]); try { size = stoull(size_str) * MB; } catch(std::exception &e){ printf("Invalid size, using default\n"); size = DEFAULT_SIZE; } i++; } break; default: printf("Invalid option \n"); exit(1); } } if (size == -1){ size = DEFAULT_SIZE; } if (path != NULL){ if (create){ printf("Creating volume of size %lld Bytes\n", size); status = rmgr->create(path, size/LSVD_SECTORSIZE); } else { status = rmgr->open(path); } } else { printf("Invalid input parameters\n"); exit(1); } if (status < 0){ perror("LSVD open error\n"); exit(1); } // Already established connection in 'p' if (prev != NULL && sendSyncRequest() < 0){ perror("ERROR sync problem!"); exit(1); } pthread_create(&d_thread, NULL, handleConnection, &d); pthread_create(&p_thread, NULL, handleConnection, &p); pthread_create(&n_thread, NULL, handleConnection, &n); pthread_join(d_thread, NULL); pthread_join(p_thread, NULL); pthread_join(n_thread, NULL); printf("Deleting rmgr, cmgr\n"); delete rmgr; // Wait for all threads to finish then delete rmgr delete cmgr; printf("Exiting main\n"); return 0; }
unsigned long long operator()(const std::string& s) { return stoull(s); }
void TrafficSimulation::import_vehicles(std::string vehicles_file) { // load input file std::ifstream infile; infile.exceptions(std::ifstream::badbit); try { infile.open(vehicles_file); // read and match lines std::string line; for (uint_fast32_t line_num = 1; std::getline(infile, line); ++line_num) { // split by fields std::vector<std::string> fields = nonstd::split(line, ':'); // 4 fields are required (time, name, from, to) if (fields.size() < 4) { std::cerr << "E: Line " << line_num << " of input file \"" << vehicles_file << "\" is not valid. See documentation " "for correct syntax. Skipping..." << std::endl; continue; } #ifndef NDEBUG std::cout << "Fields:" << std::endl; for (auto &f : fields) { std::cout << f << std::endl; } std::cout << "Matched vehicle on line " << line_num << std::endl << "name: " << fields[1] << std::endl << "from: " << fields[2] << std::endl << "to: " << fields[3] << std::endl << "starttime: " << fields[0] << std::endl; #endif // create vehicle; parse starttime, name, from and to try { Vehicle veh(*this, fields[2], fields[3], stoull(fields[0]), fields[1]); // parse optional properties for (int i = 4; i < fields.size(); ++i) { // split property field by = std::vector<std::string> property = nonstd::split(fields[i], '='); // assign property switch (nonstd::hash(property[0].c_str())) { case nonstd::hash("traffic_increase_caused"): veh.traffic_increase_caused = stof(property[1]); break; case nonstd::hash("max_speed"): veh.max_speed = stoul(property[1]); break; } } // add vehicle to simulation vehicles.push_back(veh); std::cout << "I: Vehicle " << veh.name << " loaded for simulation" << std::endl; } // vehicle construction errors catch (const std::runtime_error &e) { std::cerr << "E: " << vehicles_file << ":" << line_num << " Vehicle on line " << line_num << "could'n be loaded for simulation. " << e.what() << std::endl; } } } // input file errors catch (const std::ifstream::failure &e) { std::cerr << "E: Couldn't read file '" << vehicles_file << " " << e.what() << std::endl; } }
WSObjNumeric_JSON::operator unsigned long long int() const { string s(token->ptr,(unsigned long) token->len); return stoull(s); }
uint32_t Telecom::get_mmei(uint16_t mmegi, uint8_t mmec) { return stoull(to_string(mmegi) + to_string(mmec)); }
uint16_t Telecom::get_plmn_id(uint16_t mcc, uint16_t mnc) { return stoull(to_string(mcc) + to_string(mnc)); }
uint64_t Telecom::get_guti(uint64_t gummei, uint64_t m_tmsi) { return stoull(to_string(gummei) + to_string(m_tmsi)); }
uint64_t Telecom::get_imsi(uint16_t plmn_id, uint64_t msisdn) { return stoull(to_string(plmn_id) + to_string(msisdn)); }
uint64_t Telecom::get_gummei(uint16_t plmn_id, uint32_t mmei) { return stoull(to_string(plmn_id) + to_string(mmei)); }
std::shared_ptr<Response> request(const std::string& request_type, const std::string& path, std::ostream& content, const std::map<std::string, std::string>& header=std::map<std::string, std::string>()) { std::string corrected_path=path; if(corrected_path=="") corrected_path="/"; content.seekp(0, std::ios::end); size_t content_length=content.tellp(); content.seekp(0, std::ios::beg); boost::asio::streambuf write_buffer; std::ostream write_stream(&write_buffer); write_stream << request_type << " " << corrected_path << " HTTP/1.1\r\n"; write_stream << "Host: " << host << "\r\n"; for(auto& h: header) { write_stream << h.first << ": " << h.second << "\r\n"; } if(content_length>0) write_stream << "Content-Length: " << std::to_string(content_length) << "\r\n"; write_stream << "\r\n"; if(content_length>0) write_stream << content.rdbuf(); std::shared_ptr<Response> response(new Response()); try { connect(); boost::asio::write(*socket, write_buffer); size_t bytes_transferred = boost::asio::read_until(*socket, response->content_buffer, "\r\n\r\n"); size_t num_additional_bytes=response->content_buffer.size()-bytes_transferred; parse_response_header(response, response->content); if(response->header.count("Content-Length")>0) { boost::asio::read(*socket, response->content_buffer, boost::asio::transfer_exactly(stoull(response->header["Content-Length"])-num_additional_bytes)); } else if(response->header.count("Transfer-Encoding")>0 && response->header["Transfer-Encoding"]=="chunked") { boost::asio::streambuf streambuf; std::ostream content(&streambuf); size_t length; std::string buffer; do { size_t bytes_transferred = boost::asio::read_until(*socket, response->content_buffer, "\r\n"); std::string line; getline(response->content, line); bytes_transferred-=line.size()+1; line.pop_back(); length=stoull(line, 0, 16); size_t num_additional_bytes=response->content_buffer.size()-bytes_transferred; if((2+length)>num_additional_bytes) { boost::asio::read(*socket, response->content_buffer, boost::asio::transfer_exactly(2+length-num_additional_bytes)); } buffer.resize(length); response->content.read(&buffer[0], length); content.write(&buffer[0], length); //Remove "\r\n" response->content.get(); response->content.get(); } while(length>0); std::ostream response_content_output_stream(&response->content_buffer); response_content_output_stream << content.rdbuf(); } } catch(const std::exception& e) { socket_error=true; throw std::invalid_argument(e.what()); } return response; }
uint64_t _parse_decimal_integer_string(std::string s) { return stoull(s); }
int superpalindromesInRange(string L, string R) { vector<ULL> v{ 1, 4, 9, 121, 484, 10201, 12321, 14641, 40804, 44944, 1002001, 1234321, 4008004, 100020001, 102030201, 104060401, 121242121, 123454321, 125686521, 400080004 ,404090404, 10000200001l, 10221412201l, 12102420121l, 12345654321l, 40000800004l , 1000002000001l, 1002003002001l, 1004006004001l, 1020304030201l, 1022325232201l, 1024348434201l, 1210024200121l, 1212225222121l, 1214428244121l, 1232346432321l, 1234567654321l, 4000008000004l, 4004009004004l, 100000020000001l, 100220141022001l, 102012040210201l, 102234363432201l, 121000242000121l, 121242363242121l, 123212464212321l, 123456787654321l, 400000080000004l, 10000000200000001l, 10002000300020001l, 10004000600040001l, 10020210401202001l, 10022212521222001l, 10024214841242001l, 10201020402010201l, 10203040504030201l, 10205060806050201l, 10221432623412201l, 10223454745432201l, 12100002420000121l, 12102202520220121l, 12104402820440121l, 12122232623222121l, 12124434743442121l, 12321024642012321l, 12323244744232321l, 12343456865434321l, 12345678987654321l, 40000000800000004l, 40004000900040004l }; return upper_bound(v.begin(), v.end(), stoull(R)) - lower_bound(v.begin(), v.end(), stoull(L)); }