Points createProblem(int size){
	static bool flag = true;
	if(flag)
		std::srand(std::time(0)), flag = false;
	Points r;
	for(int i=0; i<size; i++){
		Point p = {i, rand_(), rand_()};
		r.push_back(p);
	}
	return r;
}
Example #2
0
    Eigen::VectorXd GaussianCovProposal::propose(uint id, const Eigen::VectorXd &sample, double sigma)
    {
      uint n = sample.size();

      Eigen::VectorXd randn(n);
      for (uint i = 0; i < n; i++)
        randn(i) = rand_(gen_);

      return sample + sigL_[id] * randn * sigma * sigma;
    }
Example #3
0
void
train(net_t *net, int n, nfloat_t *set, int rows_n, int image_size, int output_size)
{
  int       i = 0, j = 0, r = 0;
  int       input_size = image_size * image_size;
  nfloat_t  *input, *output;
  int       *hash;

  input = (nfloat_t *) malloc(input_size * sizeof(nfloat_t));
  hash = (int *) malloc(rows_n * sizeof(int));

  for (i = 0; i < rows_n; ++i)
    hash[i] = i;

  for (i = 0; i < rows_n; ++i) {
    r = rand_(0, rows_n - 1);
    j = hash[i];
    hash[i] = hash[r];
    hash[r] = j;
  }

  for (i = 0; i < rows_n; ++i) {
    r = hash[i];
    //input = set + r * (input_size + output_size);
    memcpy(input, set + r * (input_size + output_size), input_size * sizeof(nfloat_t));

    /* Zakłócenia */
    for (j = 0; j < input_size; ++j) {
      input[j] += ((nfloat_t) rand() / RAND_MAX) * 0.2 + 0.1;
      if (input[j] < -1) input[j] = -1;
      if (input[j] > 1) input[j] = 1;
    }

    for (j = 0; j < rand_(0, 5); ++j)
      input[rand_(0, input_size - 1)] = rand_(0, 1) == 0 ? 1.0 : -1.0;

    output = set + r * (input_size + output_size) + input_size;

    //~ print_input_data(input, image_size);
    //~ print_output_data(output, output_size);
    net_learn(net, N, input, output);
  }
}
Example #4
0
bool MonteCarlo::do_accept_or_reject_move(double score, double last,
        double proposal_ratio) {
    bool ok = false;
    if (score < last) {
        ++stat_downward_steps_taken_;
        ok = true;
        if (score < best_energy_ && return_best_) {
            best_ = new Configuration(get_model());
            best_energy_ = score;
        }
    } else {
        double diff = score - last;
        double e = std::exp(-diff / temp_);
        double r = rand_(random_number_generator);
        IMP_LOG_VERBOSE(diff << " " << temp_ << " " << e << " " << r << std::endl);
        if (e * proposal_ratio > r) {
            ++stat_upward_steps_taken_;
            ok = true;
        } else {
            ok = false;
        }
    }
    if (ok) {
        IMP_LOG_TERSE("Accept: " << score << " previous score was " << last
                      << std::endl);
        last_energy_ = score;
        update_states();
        for (int i = get_number_of_movers() - 1; i >= 0; --i) {
            get_mover(i)->accept();
        }
        return true;
    } else {
        IMP_LOG_TERSE("Reject: " << score << " current score stays " << last
                      << std::endl);
        for (int i = get_number_of_movers() - 1; i >= 0; --i) {
            get_mover(i)->reject();
        }
        ++stat_num_failures_;
        if (isf_) {
            isf_->reset_moved_particles();
        }
        return false;
    }
}
Example #5
0
Random::Random() :
mt_(rand_()) {}
Example #6
0
int mersenne_twister_u16(int low, int high)
{
	std::uniform_int_distribution<> rand_(low, high);
	return static_cast<int>(rand_(mt));
}
Example #7
0
float mersenne_twister_f32(float low, float high){
	std::uniform_real_distribution<> rand_(low, high);
	return static_cast<float>(rand_(mt));
}
Example #8
0
/*     P. 704. */
doublereal dgrand_(integer *n)
{
    /* Initialized data */

    static doublereal d__[60] = { .67448975,.47585963,.383771164,.328611323,
	    .291142827,.263684322,.242508452,.225567444,.211634166,.199924267,
	    .189910758,.181225181,.1736014,.166841909,.160796729,.155349717,
	    .150409384,.145902577,.141770033,.137963174,.134441762,.13117215,
	    .128125965,.12527909,.122610883,.12010356,.117741707,.115511892,
	    .113402349,.11140272,.109503852,.107697617,.105976772,.104334841,
	    .102766012,.101265052,.099827234,.098448282,.097124309,.095851778,
	    .094627461,.093448407,.092311909,.091215482,.090156838,.089133867,
	    .088144619,.087187293,.086260215,.085361834,.084490706,.083645487,
	    .082824924,.082027847,.081253162,.080499844,.079766932,.079053527,
	    .078358781,.077681899 };
    static doublereal u = 0.f;

    /* System generated locals */
    doublereal ret_val;

    /* Local variables */
    static doublereal a;
    static integer i__;
    static doublereal v, w;
    extern doublereal rand_(integer *);

/* EXCEPT ON THE FIRST CALL GRAND RETURNS A */
/* PSEUDO-RANDOM NUMBER HAVING A GAUSSIAN (I.E. */
/* NORMAL) DISTRIBUTION WITH ZERO MEAN AND UNIT */
/* STANDARD DEVIATION.  THUS, THE DENSITY IS  F(X) = */
/* EXP(-0.5*X**2)/SQRT(2.0*PI). THE FIRST CALL */
/* INITIALIZES GRAND AND RETURNS ZERO. */
/* THE PARAMETER N IS DUMMY. */
/* GRAND CALLS A FUNCTION RAND, AND IT IS ASSUMED THAT */
/* SUCCESSIVE CALLS TO RAND(0) GIVE INDEPENDENT */
/* PSEUDO- RANDOM NUMBERS DISTRIBUTED UNIFORMLY ON (0, */
/* 1), POSSIBLY INCLUDING 0 (BUT NOT 1). */
/* THE METHOD USED WAS SUGGESTED BY VON NEUMANN, AND */
/* IMPROVED BY FORSYTHE, AHRENS, DIETER AND BRENT. */
/* ON THE AVERAGE THERE ARE 1.37746 CALLS OF RAND FOR */
/* EACH CALL OF GRAND. */
/* WARNING - DIMENSION AND DATA STATEMENTS BELOW ARE */
/*           MACHINE-DEPENDENT. */
/* DIMENSION OF D MUST BE AT LEAST THE NUMBER OF BITS */
/* IN THE FRACTION OF A FLOATING-POINT NUMBER. */
/* THUS, ON MOST MACHINES THE DATA STATEMENT BELOW */
/* CAN BE TRUNCATED. */
/* IF THE INTEGRAL OF SQRT(2.0/PI)*EXP(-0.5*X**2) FROM */
/* A(I) TO INFINITY IS 2**(-I), THEN D(I) = A(I) - */
/* A(I-1). */
/* END OF MACHINE-DEPENDENT STATEMENTS */
/* U MUST BE PRESERVED BETWEEN CALLS. */
/* INITIALIZE DISPLACEMENT A AND COUNTER I. */
    a = 0.f;
    i__ = 0;
/* INCREMENT COUNTER AND DISPLACEMENT IF LEADING BIT */
/* OF U IS ONE. */
L10:
    u += u;
    if (u < 1.f) {
	goto L20;
    }
    u += -1.f;
    ++i__;
    a -= d__[i__ - 1];
    goto L10;
/* FORM W UNIFORM ON 0 .LE. W .LT. D(I+1) FROM U. */
L20:
    w = d__[i__] * u;
/* FORM V = 0.5*((W-A)**2 - A**2). NOTE THAT 0 .LE. V */
/* .LT. LOG(2). */
    v = w * (w * .5f - a);
/* GENERATE NEW UNIFORM U. */
L30:
    u = rand_(&c__0);
/* ACCEPT W AS A RANDOM SAMPLE IF V .LE. U. */
    if (v <= u) {
	goto L40;
    }
/* GENERATE RANDOM V. */
    v = rand_(&c__0);
/* LOOP IF U .GT. V. */
    if (u > v) {
	goto L30;
    }
/* REJECT W AND FORM A NEW UNIFORM U FROM V AND U. */
    u = (v - u) / (1.f - u);
    goto L20;
/* FORM NEW U (TO BE USED ON NEXT CALL) FROM U AND V. */
L40:
    u = (u - v) / (1.f - v);
/* USE FIRST BIT OF U FOR SIGN, RETURN NORMAL VARIATE. */
    u += u;
    if (u < 1.f) {
	goto L50;
    }
    u += -1.f;
    ret_val = w - a;
    return ret_val;
L50:
    ret_val = a - w;
    return ret_val;
} /* dgrand_ */
Example #9
0
 Storage* get_random() {
     return storages_[rand_(storages_.size())];
 }