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());
}
}
}
