void run() { boost::random::mt19937 gen; std::string chars( "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "1234567890" "!@#$%^&*()" "`~-_=+[{]{\\|;:'\",<.>/? "); boost::random::uniform_int_distribution<> dist(1, 200); boost::random::uniform_int_distribution<> index_dist(0, chars.size() - 1); while(true) { boost::this_thread::sleep_for(boost::chrono::milliseconds(dist(gen))); std::stringstream ss; ss << m_packet_cnt++ << " " << ">| "; for(int i = 0; i < 8; ++i) { ss << chars[index_dist(gen)]; } ss << " |<" << std::endl; m_svc.pushReadBuffer(ss.str()); } }
// ------------------------------------------------------------- // PETScConfigurable::p_generatePrefix // ------------------------------------------------------------- std::string PETScConfigurable::p_generatePrefix(void) { static const int prefix_len(4); static std::string chars("abcdefghijklmnopqrstuvwxyz"); boost::random::random_device rng; boost::random::uniform_int_distribution<> index_dist(0, chars.size() - 1); std::string result(""); for(int i = 0; i < prefix_len; ++i) { result += chars[index_dist(rng)]; } return result; }
std::string ddp::random_id(unsigned int length) const { std::string id; std::string const chars( "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "1234567890" ); boost::random::random_device random; boost::random::uniform_int_distribution<> index_dist(0, chars.size() - 1); for(unsigned int i = 0; i < length; ++i) { id += chars[index_dist(random)]; } return id; }
std::string LinkImpl::makename() { //generate random name std::string name; const std::string chars( "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ); boost::random::random_device rng; boost::random::uniform_int_distribution<> index_dist(0, chars.size() - 1); for(int i = 0; i < 8; ++i) { name.push_back(chars[index_dist(rng)]); } return std::move(name); }
std::string GenerateRandomString(size_t length) { std::string str; for (size_t i = 0; i < length; ++i) str += chars[index_dist(rng)]; return str; }
void benchmark_sw( boost::random::mt19937& rng , boost::uint32_t seed , boost::uint32_t length , boost::uint32_t grain_size , boost::uint32_t iterations = 1 << 10 ) { std::string const chars("ATGC"); boost::random::uniform_int_distribution<boost::uint32_t> index_dist(0, chars.size() - 1); /////////////////////////////////////////////////////////////////////////// // Generate our sequences using the mt19937 random number generator. std::string a, b; for (boost::uint32_t x = 0; x < length; ++x) { a += chars[index_dist(rng)]; b += chars[index_dist(rng)]; } /////////////////////////////////////////////////////////////////////////// // Generate our sequences using the mt19937 random number generator. hpx::util::high_resolution_timer t; for (boost::uint32_t x = 0; x < iterations; ++x) smith_waterman(a, b, grain_size); double runtime = t.elapsed(); std::cout << seed << "," << hpx::get_os_thread_count() << "," << length << "," << grain_size << "," << iterations << "," << runtime << "\n"; }
template <typename PointInT> void RejectivePointCloudCoherence<PointInT>::computeSampledCoherence ( const PointCloudInConstPtr &cloud, const Eigen::Affine3f &trans, float &w) { // std::unordered_multimap<int, int> index_map; // index_map.reserve (cloud->size ()); // std::map <int,double> min_w_map; std::map <int, int> target_model_map; //Compute Half of Hausdorff distance std::vector<int> k_indices(1); std::vector<float> k_distances(1); float max_dist = -1.0f * std::numeric_limits<float>::max (); float sum_max_dist = 0.0f; double val = 1.0; int interval = cloud->points.size () / num_samples_; PointInT transformed_pt; //Now search for transformed_pt instead //Main problem - need to pass transform //float r1=0,r2=0, g1=0,g2=0,b1=0,b2=0; if (interval < 2) //Special case - use every point, no random { for (size_t i = 0; i < cloud->points.size (); i++) { transformed_pt.getVector3fMap () = trans * cloud->points[i].getVector3fMap (); transformed_pt.rgb = cloud->points[i].rgb; search_->nearestKSearch (transformed_pt, 1, k_indices, k_distances); k_distances[0] = sqrt (k_distances[0]); if (k_distances[0] > max_dist) max_dist = k_distances[0]; if (k_distances[0] < maximum_distance_) val += computeScoreHSV (target_input_->points[k_indices[0]], transformed_pt, k_distances[0]); sum_max_dist += k_distances[0]; } } else //otherwise randomly sample at regular intervals { boost::uniform_int<int> index_dist(0, interval); int max_offset = cloud->points.size () - interval; for (size_t offset = 0; offset < max_offset; offset += interval) { int idx = offset + index_dist(rng_); transformed_pt.getVector3fMap () = trans * cloud->points[idx].getVector3fMap (); transformed_pt.rgb = cloud->points[idx].rgb; search_->nearestKSearch (transformed_pt, 1, k_indices, k_distances); k_distances[0] = sqrt (k_distances[0]); if (k_distances[0] > max_dist) max_dist = k_distances[0]; if (k_distances[0] < maximum_distance_) val += computeScoreHSV (target_input_->points[k_indices[0]], transformed_pt, k_distances[0]); sum_max_dist += k_distances[0]; } } //Max distance allowed - coherence is zero if ANY points are too far away if (max_dist > 0.05f) { // std::cout <<"REJECTING MAX\n"; w = -1.0f * std::numeric_limits<float>::min (); return; } //Avereage max distance of points - coherence is zero if average is too large float avg_max_dist = sqrt(sum_max_dist) / cloud->points.size (); if (avg_max_dist > 0.02f) { // std::cout <<"REJECTING AVG\n"; w = -1.0f * std::numeric_limits<float>::min (); return; } w = - static_cast<float> (val); }
static void test(securefs::BtreeDirectory& dir, securefs::Directory& reference, unsigned rounds, double prob_get, double prob_add, double prob_del, unsigned sequence) { (void)sequence; // May be used later bool is_prob_valid = (prob_get >= 0 && prob_add >= 0 && prob_del >= 0 && prob_get + prob_add + prob_del <= 1.0); REQUIRE(is_prob_valid); std::mt19937 engine{std::random_device{}()}; std::uniform_real_distribution<> prob_dist(0, 1); std::uniform_int_distribution<int> name_dist(0, 65535); std::vector<std::string> filenames, filenames_prime; securefs::Directory::callback inserter = [&](const std::string& name, const securefs::id_type&, int) -> bool { filenames.push_back(name); return true; }; securefs::Directory::callback inserter_prime = [&](const std::string& name, const securefs::id_type&, int) -> bool { filenames_prime.push_back(name); return true; }; dir.iterate_over_entries(inserter); reference.iterate_over_entries(inserter_prime); std::sort(filenames.begin(), filenames.end()); std::sort(filenames_prime.begin(), filenames_prime.end()); bool equal_filenames = (filenames == filenames_prime); REQUIRE(equal_filenames); securefs::id_type id, id_prime; int type, type_prime; for (unsigned i = 0; i < rounds; ++i) { auto p = prob_dist(engine); if (p < prob_get) { filenames.clear(); dir.iterate_over_entries(inserter); for (const std::string& n : filenames) { bool got = dir.get_entry(n, id, type); bool got_prime = reference.get_entry(n, id_prime, type_prime); REQUIRE(got == got_prime); REQUIRE(id == id_prime); REQUIRE(type == type_prime); } } else if (p < prob_get + prob_add) { auto name = fmt::format("{0:12d}", name_dist(engine)); securefs::generate_random(id.data(), id.size()); type = S_IFREG; bool added = dir.add_entry(name, id, type); bool added_prime = reference.add_entry(name, id, type); REQUIRE(added == added_prime); filenames.push_back(std::move(name)); } else if (p < prob_get + prob_add + prob_del) { if (filenames.empty()) continue; std::uniform_int_distribution<size_t> index_dist(0, filenames.size() - 1); size_t idx = index_dist(engine); bool removed = dir.remove_entry(filenames[idx], id, type); bool removed_prime = reference.remove_entry(filenames[idx], id_prime, type_prime); REQUIRE(removed == removed_prime); filenames.erase(filenames.begin() + idx); } else { REQUIRE(dir.validate_free_list()); REQUIRE(dir.validate_btree_structure()); } } }