//generator pseudonahodnych cisiel exponencialneho rozlozenia so stredom v x
double Model::GeneratorExp(double x)
{
std::mt19937 rng((int)std::time(0) * RandomGenerator()); //ak sa generator zavola v rovnakom strojovom case generuje rovnake hodnoty
std::exponential_distribution<double> distrib(1 / x); //semienko je teda vynasobene nahodnym cislom z intervalu 0 - 100
return distrib(rng);
}
//generator pseudonahodnych cisiel, rovnomerne rozlozenie z intervalu
//<a, b>; implicitne hodnoty: a=1, b=100
//pouziva sa pre urcenie pravdepodobnosti
int Model::RandomGenerator(int a, int b)
{
std::random_device rand;
std::uniform_int_distribution<int> distrib(a, b);
std::mt19937 rng(rand());
return distrib(rng);
}
extern "C" int main(int ac, char **av)
{
MPI_CALL(Init(&ac, &av));
ospcommon::tasking::initTaskingSystem();
maml::init();
std::mt19937 rng(std::random_device{}());
std::uniform_int_distribution<int> distrib(0, 255);
int numRuns = 1000000;
int rank = -1;
int numRanks = 0;
MPI_CALL(Comm_size(MPI_COMM_WORLD,&numRanks));
MPI_CALL(Comm_rank(MPI_COMM_WORLD,&rank));
int numMessages = 100;
int payloadSize = 100000;
MyHandler handler;
maml::registerHandlerFor(MPI_COMM_WORLD,&handler);
char *payload = (char*)malloc(payloadSize);
for (int i=0;i<payloadSize;i++)
payload[i] = distrib(rng);
for (int run=0;run<numRuns;run++) {
MPI_CALL(Barrier(MPI_COMM_WORLD));
double t0 = ospcommon::getSysTime();
maml::start();
for (int mID=0;mID<numMessages;mID++) {
for (int r=0;r<numRanks;r++) {
maml::sendTo(MPI_COMM_WORLD,r,std::make_shared<maml::Message>(payload,payloadSize));
}
}
while (handler.numReceived != numRanks*numMessages*(run+1)) {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
maml::stop();
double t1 = ospcommon::getSysTime();
double bytes = numRanks * numMessages * payloadSize / (t1-t0);
std::string rate = ospcommon::prettyNumber(bytes);
printf("rank %i: received %i messages in %lf secs; that is %sB/s\n",rank,numRanks*numMessages,t1-t0,
rate.c_str());
MPI_CALL(Barrier(MPI_COMM_WORLD));
}
maml::shutdown();
MPI_CALL(Barrier(MPI_COMM_WORLD));
MPI_Finalize();
}
int main()
{
KarpShenker ks(0.2);
std::mt19937 seed(getpid());
std::normal_distribution<double> distrib(500.0, 20.0);
for (int i = 0; i < 1000; i++)
{
uint32_t idx = distrib(seed)/10;
std::cout << idx << std::endl;
ks.insert(idx);
}
std::cout << ks << std::endl;
}
random_switch_task::random_switch_task(std::shared_ptr<graph_data> graph_data, double mu, size_t step_count, size_t graph_step, const std::string& output_dir) :
base_task(graph_data, mu, step_count, graph_step, output_dir)
{
undirected_graph& graph_ = gr_data_->graph_;
size_t vertices_count = boost::num_vertices(graph_);
size_t all_edges_count = vertices_count * (vertices_count - 1) / 2;
size_t non_existing_edges_count = all_edges_count - boost::num_edges(graph_);
non_existing_edges_.reserve(non_existing_edges_count);
vertex_iterator v, v_end;
boost::tie(v, v_end) = boost::vertices(graph_);
size_t index = 0;
for(; v != v_end; ++v)
{
vertex_iterator v1 = v;
for(++v1; v1 != v_end; ++v1)
{
if(!boost::edge(*v, *v1, graph_).second)
{
non_existing_edges_.push_back(std::make_pair(*v, *v1));
}
}
}
std::uniform_int_distribution<> distrib(0, non_existing_edges_.size() - 1);
var_generator_ = new boost::variate_generator<random_generator, std::uniform_int_distribution<>>(rand_generator_, distrib);
}
const Key& CountDictionary<Key>::sample(){
//put that somewhere else...
if(!sampling_allowed){
std::vector<double> w(this->dict.size());
arg_vec.resize(this->dict.size());
int idx = 0;
for(typename std::unordered_map<Key,unsigned>::iterator it = this->dict.begin();it != this->dict.end();++it){
arg_vec[idx] = it->first;
w[idx] = it->second;
++idx;
}
std::discrete_distribution<int> dtmp(w.begin(),w.end());
distrib.param(dtmp.param());
/*
std::vector<double> p = distrib.probabilities();
for(int i = 0; i < p.size();++i){
std::cout << arg_vec[i] << p[i] << endl;
}
*/
sampling_allowed = true;
}
//distrib.reset() ?;
return arg_vec[distrib(rd_generator)];
}
static
BOOL arith_rel_quasi_eval(Term atom)
{
/* This is an initial version for testing only. */
if (SYMNUM(atom) == Eq_sn) {
BOOL negated = NEGATED(atom);
Term atom2 = copy_term(atom);
BOOL val;
atom2 = distrib(atom2);
/* printf("after distrib: "); fwrite_term_nl(stdout, atom2); */
ac_canonical2(atom2, -1, term_compare_vcp);
/* printf("after AC canon: "); fwrite_term_nl(stdout, atom2); */
ARG(atom2,0) = qsimp(ARG(atom2,0));
ARG(atom2,1) = qsimp(ARG(atom2,1));
/* printf("after qsimp: "); fwrite_term_nl(stdout, atom2); */
if (term_ident(ARG(atom2,0), ARG(atom2,1)))
val = negated ? FALSE : TRUE;
else
val = FALSE;
zap_term(atom2);
return val;
}
else
return FALSE;
} /* arith_rel_quasi_eval */
/**
* @brief Generate a real using an exponential distribution.
* @param rate
* @return a real between 0 and infinite.
*/
double exponential(double rate)
{
boost::exponential_distribution < > distrib(rate);
boost::variate_generator < boost::mt19937&,
boost::exponential_distribution < > > gen(m_rand, distrib);
return gen();
}
/**
* @brief Generate a real using the Log Normal law.
* @param mean
* @param sigma
* @return a real.
*/
double logNormal(double mean, double sigma)
{
boost::lognormal_distribution < > distrib(mean, sigma);
boost::variate_generator < boost::mt19937&,
boost::lognormal_distribution < > > gen(m_rand, distrib);
return gen();
}
/**
* @brief Generate a real from begin to end [begin..end).
* @param begin The minimum value.
* @param end The limit (exclude) of the range.
* @return a random real.
*/
inline double getDouble(double begin, double end)
{
boost::uniform_real < > distrib(begin, end);
boost::variate_generator < boost::mt19937&,
boost::uniform_real < > > gen(m_rand, distrib);
return gen();
}
/**
* @brief Generate a real value [0, 1)
* @return a random real.
*/
inline double getDouble()
{
boost::uniform_real < > distrib(0.0, 1.0);
boost::variate_generator < boost::mt19937&,
boost::uniform_real < > > gen(m_rand, distrib);
return gen();
}
/**
* @brief Generate an integer from begin to end [begin..end].
* @param begin The minimum value include.
* @param end The limit of the range.
* @return a random integer.
*/
inline int getInt(int begin, int end)
{
boost::uniform_int < > distrib(begin, end);
boost::variate_generator < boost::mt19937&,
boost::uniform_int < > > gen(m_rand, distrib);
return gen();
}
void put_dots(t_dot *dot, t_mlx mlx)
{
int ct;
ct = 0;
mlx.mlx = mlx_init();
mlx.win = mlx_new_window(mlx.mlx, 1600, 1600, "lol");
while (!(dot + ct)->end)
{
distrib(*(dot + ct), *(dot + ct + 1), mlx);
if ((ct / mlx.len) != mlx.line - 1)
distrib(*(dot + ct), *(dot + ct + mlx.len), mlx);
ct++;
}
mlx_key_hook(mlx.win, ft_quit, NULL);
mlx_loop(mlx.mlx);
}
/**
* @brief Generate a real using the Poisson distribution.
* @param mean
* @return a real.
*/
double poisson(double mean)
{
boost::poisson_distribution < > distrib(mean);
boost::variate_generator < boost::mt19937&,
boost::poisson_distribution < > > gen(m_rand, distrib);
return gen();
}
/**
* @brief Generate a real using the Gamma distribution.
* @param alpha
* @return a real.
*/
double gamma(double alpha)
{
boost::gamma_distribution < > distrib(alpha);
boost::variate_generator < boost::mt19937&,
boost::gamma_distribution < > > gen(m_rand, distrib);
return gen();
}
/**
* @brief Generate a real using the triangular law.
* @param a
* @param b
* @param c
* @return a real.
*/
double triangle(double a, double b, double c)
{
boost::triangle_distribution < > distrib(a, b, c);
boost::variate_generator < boost::mt19937&,
boost::triangle_distribution < > > gen(m_rand, distrib);
return gen();
}
/**
* @brief Generate a real using the Cauchy law.
* @param median
* @param sigma
* @return a real.
*/
double cauchy(double median, double sigma)
{
boost::cauchy_distribution < > distrib(median, sigma);
boost::variate_generator < boost::mt19937&,
boost::cauchy_distribution < > > gen(m_rand, distrib);
return gen();
}
/**
* @brief Generate a real using the Geometric distribution.
* @param p
* @return a real.
*/
double geometric(double p)
{
boost::geometric_distribution < > distrib(p);
boost::variate_generator < boost::mt19937&,
boost::geometric_distribution < > > gen(m_rand, distrib);
return gen();
}
/**
* @brief Generate a real using the Binomial distribution.
* @param t
* @param p
* @return a real.
*/
double binomial(int t, double p)
{
boost::binomial_distribution < > distrib(t, p);
boost::variate_generator < boost::mt19937&,
boost::binomial_distribution < > > gen(m_rand, distrib);
return gen();
}
void modul(t_precis *nb, t_flag *flag, char *format, int *len)
{
distrib(nb, flag, format);
nb->j = double_modulo(nb, format);
if (nb->min != 0)
*len += nb->min;
else
(*len)++;
}
double StdMaterial::lightFreePathLength(const Raycast& ray) const
{
double opa = opacity(ray.origin);
if(opa <= 0.0)
{
return Raycast::BACKDROP_LIMIT;
}
else if(opa >= 1.0)
{
return 0.0;
}
else
{
double scatterRate = 1 / (1 / (opa) - 1);
std::exponential_distribution<> distrib(scatterRate);
return distrib(_randomEngine);
}
}
std::size_t generate_random_number(unsigned min, unsigned max) {
std::mt19937 typedef generator_t;
std::random_device generate_seed;
generator_t gen(generate_seed());
boost::uniform_int<> distrib(min, max);
//std::uniform_int<> distrib(min, max);
std::function<size_t()> uni_random(std::bind(distrib, gen));
return uni_random();
}
void Population::Mutation(void)
{
unsigned int index;
std::default_random_engine gen;
std::uniform_int_distribution<int> distrib('a', 'z');
std::uniform_real_distribution<double> distrib_d(0,1);
std::vector<char> genes;
for (std::list<Chromosome *>::iterator it = _samples.begin(); it != _samples.end(); ++it)
{
if (distrib_d(gen) <= _mutation_rate)
{
index = RandomInt(0, _gene_size);
genes = (*it)->getGenes();
genes[index] = (char)distrib(gen);
(*it)->setGenes(genes);
}
}
}
static
Term distrib(Term t)
{
if (VARIABLE(t))
return t;
else {
int i;
for (i = 0; i < ARITY(t); i++)
ARG(t,i) = distrib(ARG(t,i));
if (SYMNUM(t) != Prod_sn)
return t;
else {
if (SYMNUM(ARG(t,1)) == Sum_sn) {
/* a*(b+c) */
Term a = ARG(t,0);
Term b = ARG(ARG(t,1),0);
Term c = ARG(ARG(t,1),1);
free_term(ARG(t,1));
free_term(t);
return build_binary_term(Sum_sn,
distrib(build_binary_term(Prod_sn, a, b)),
distrib(build_binary_term(Prod_sn, copy_term(a), c)));
}
else if (SYMNUM(ARG(t,0)) == Sum_sn) {
/* (b+c)*a */
Term a = ARG(t,1);
Term b = ARG(ARG(t,0),0);
Term c = ARG(ARG(t,0),1);
free_term(ARG(t,0));
free_term(t);
return build_binary_term(Sum_sn,
distrib(build_binary_term(Prod_sn, b, a)),
distrib(build_binary_term(Prod_sn, c, copy_term(a))));
}
else
return t;
}
}
} /* distrib */
typename graph_traits<Graph>::edge_descriptor
random_edge(Graph& g, RandomNumGen& gen) {
if (num_edges(g) > 1) {
uniform_int<> distrib(0, num_edges(g)-1);
variate_generator<RandomNumGen&, uniform_int<> > rand_gen(gen, distrib);
typename graph_traits<Graph>::edges_size_type
n = rand_gen();
typename graph_traits<Graph>::edge_iterator
i = edges(g).first;
while (n-- > 0) ++i; // std::advance not VC++ portable
return *i;
} else
return *edges(g).first;
}
typename graph_traits<Graph>::vertex_descriptor
random_vertex(Graph& g, RandomNumGen& gen)
{
if (num_vertices(g) > 1) {
#if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581))
std::size_t n = std::random( num_vertices(g) );
#else
uniform_int<> distrib(0, num_vertices(g)-1);
variate_generator<RandomNumGen&, uniform_int<> > rand_gen(gen, distrib);
std::size_t n = rand_gen();
#endif
typename graph_traits<Graph>::vertex_iterator
i = vertices(g).first;
return *(boost::next(i, n));
} else
return *vertices(g).first;
}
graph_types::remove_add_edges_pair random_switch_randomizer::get_step()
{
graph_types::remove_add_edges_pair r_a_p;
std::uniform_int_distribution<> distrib(0,
m_non_existing_edges.size() - 1);
auto variate_generator = new boost::variate_generator<
graph_types::random_generator,
std::uniform_int_distribution<>>(m_random_generator, distrib);
graph_types::edge e1 = m_graph.random_edge(m_random_generator);
r_a_p.first.push_back(e1);
unsigned n_e_e_index = (*variate_generator)();
auto& e2 = m_non_existing_edges[n_e_e_index];
assert(!m_graph.edge_exists(e2));
r_a_p.second.push_back(e2);
m_non_existing_edges.erase(m_non_existing_edges.begin() + n_e_e_index);
delete variate_generator;
return r_a_p;
}
void Plazza::start()
{
draw_menu();
draw_log();
char buff[4096];
std::string line;
while (line != "quit")
{
printEcrased();
move(40, 2);
clrtoeol();
getstr(buff);
line.assign(buff);
parsing(line);
distrib();
wclrtoeol(_footer);
}
}
static void up_handler(state_t s, event_t e, unmarsh_t abv) {
endpt_id_t origin ;
unmarsh_endpt_id(abv, &origin) ;
if (s->partition) {
sys_abort() ;
} else {
etime_t delay ;
if (!distrib(s, &delay)) {
up_free(e, abv) ;
} else {
etime_t when = time_add(alarm_gettime(s->alarm), delay) ;
item_t item = record_create(item_t, item) ;
/*eprintf("type=%s\n", event_type_to_string(event_type(e))) ;*/
item->type = DROP_UP ;
item->u.up.event = e ;
item->u.up.abv = abv ;
priq_add(s->priq, when, item) ;
dnnm(s, event_timer_time(when)) ;
}
}
}
const Distribution1D *SpatialLightDistribution::Lookup(const Point3f &p) const {
ProfilePhase _(Prof::LightDistribLookup);
++nLookups;
// Compute integer voxel coordinates for the given point |p| with
// respect to the overall voxel grid.
Vector3f offset = scene.WorldBound().Offset(p); // offset in [0,1].
Point3i pi;
for (int i = 0; i < 3; ++i) pi[i] = int(offset[i] * nVoxels[i]);
// Create the per-thread cache of sampling distributions if needed.
LocalBucketHash *localVoxelDistribution =
localVoxelDistributions[ThreadIndex].get();
if (!localVoxelDistribution) {
LOG(INFO) << "Created per-thread SpatialLightDistribution for thread" <<
ThreadIndex;
localVoxelDistribution = new LocalBucketHash;
localVoxelDistributions[ThreadIndex].reset(localVoxelDistribution);
}
else {
// Otherwise see if we have a sampling distribution for the voxel
// that |p| is in already available in the local cache.
auto iter = localVoxelDistribution->find(pi);
if (iter != localVoxelDistribution->end())
return iter->second;
}
// Now we need to either get the distribution from the shared hash
// table (if another thread has already created it), or create it
// ourselves and add it to the shared table.
ProfilePhase __(Prof::LightDistribLookupL2);
// First, compute a hash into the first-level hash table.
size_t hash = std::hash<int>{}(pi[0] + nVoxels[0] * pi[1] +
nVoxels[0] * nVoxels[1] * pi[2]);
hash &= (nBuckets - 1);
// Acquire the lock for the corresponding second-level hash table.
std::lock_guard<std::mutex> lock(mutexes[hash]);
// See if we can find it.
auto iter = voxelDistribution[hash].find(pi);
if (iter != voxelDistribution[hash].end()) {
// Success. Add the pointer to the thread-specific hash table so
// that we can look up this distribution more efficiently in the
// future.
(*localVoxelDistribution)[pi] = iter->second.get();
return iter->second.get();
}
// We need to compute a new sampling distriibution for this voxel. Note
// that we're holding the lock for the first-level hash table bucket
// throughout the following; in general, we'd like to do the following
// quickly so that other threads don't get held up waiting for that
// lock (for this or other voxels that share it).
ProfilePhase ___(Prof::LightDistribCreation);
++nCreated;
++nDistributions;
// Compute the world-space bounding box of the voxel.
Point3f p0(Float(pi[0]) / Float(nVoxels[0]),
Float(pi[1]) / Float(nVoxels[1]),
Float(pi[2]) / Float(nVoxels[2]));
Point3f p1(Float(pi[0] + 1) / Float(nVoxels[0]),
Float(pi[1] + 1) / Float(nVoxels[1]),
Float(pi[2] + 1) / Float(nVoxels[2]));
Bounds3f voxelBounds(scene.WorldBound().Lerp(p0),
scene.WorldBound().Lerp(p1));
// Compute the sampling distribution. Sample a number of points inside
// voxelBounds using a 3D Halton sequence; at each one, sample each
// light source and compute a weight based on Li/pdf for the light's
// sample (ignoring visibility between the point in the voxel and the
// point on the light source) as an approximation to how much the light
// is likely to contribute to illumination in the voxel.
int nSamples = 128;
std::vector<Float> lightContrib(scene.lights.size(), Float(0));
for (int i = 0; i < nSamples; ++i) {
Point3f po = voxelBounds.Lerp(Point3f(
RadicalInverse(0, i), RadicalInverse(1, i), RadicalInverse(2, i)));
Interaction intr(po, Normal3f(), Vector3f(), Vector3f(1, 0, 0),
0 /* time */, MediumInterface());
// Use the next two Halton dimensions to sample a point on the
// light source.
Point2f u(RadicalInverse(3, i), RadicalInverse(4, i));
for (size_t j = 0; j < scene.lights.size(); ++j) {
Float pdf;
Vector3f wi;
VisibilityTester vis;
Spectrum Li = scene.lights[j]->Sample_Li(intr, u, &wi, &pdf, &vis);
if (pdf > 0) {
// TODO: look at tracing shadow rays / computing beam
// transmittance. Probably shouldn't give those full weight
// but instead e.g. have an occluded shadow ray scale down
// the contribution by 10 or something.
lightContrib[j] += Li.y() / pdf;
}
}
}
// We don't want to leave any lights with a zero probability; it's
// possible that a light contributes to points in the voxel even though
// we didn't find such a point when sampling above. Therefore, compute
// a minimum (small) weight and ensure that all lights are given at
// least the corresponding probability.
Float sumContrib =
std::accumulate(lightContrib.begin(), lightContrib.end(), Float(0));
Float avgContrib = sumContrib / (nSamples * lightContrib.size());
Float minContrib = (avgContrib > 0) ? .001 * avgContrib : 1;
for (size_t i = 0; i < lightContrib.size(); ++i) {
VLOG(2) << "Voxel pi = " << pi << ", light " << i << " contrib = "
<< lightContrib[i];
lightContrib[i] = std::max(lightContrib[i], minContrib);
}
LOG(INFO) << "Initialized light distribution in voxel pi= " << pi <<
", avgContrib = " << avgContrib;
// Compute a sampling distribution from the accumulated
// contributions.
std::unique_ptr<Distribution1D> distrib(
new Distribution1D(&lightContrib[0], lightContrib.size()));
// Store a pointer to it in the per-thread cache for the future.
(*localVoxelDistribution)[pi] = distrib.get();
// Store the canonical unique_ptr for it in the global hash table so
// other threads can use it.
voxelDistribution[hash][pi] = std::move(distrib);
return (*localVoxelDistribution)[pi];
}
