VALUE rng_get_rand(VALUE self) {
VALUE stream_ptr = rb_iv_get(self, "@stream_prt");
RngStream stream;
Data_Get_Struct(stream_ptr, RngStream, stream);
double rand_value = RngStream_RandU01(stream);
return rb_float_new(rand_value);
}
SEXP R_RngStreams_Sample (SEXP R_stream, SEXP R_size)
/*----------------------------------------------------------------------*/
/* Sample from Stream object. */
/* */
/* parameters: */
/* R_stream ... (pointer) ... pointer the Stream object */
/* R_size ... (int) ... sample size */
/* */
/* return: */
/* pointer to stream object */
/*----------------------------------------------------------------------*/
{
RngStream stream;
int n = INTEGER(R_size)[0];
int i;
SEXP R_sample;
/* check pointer */
CHECK_STREAM_PTR(R_stream);
/* Extract pointer to generator */
stream = R_ExternalPtrAddr(R_stream);
CHECK_NULL(stream);
/* generate random sample of size n */
PROTECT(R_sample = NEW_NUMERIC(n));
for (i=0; i<n; i++)
NUMERIC_POINTER(R_sample)[i] = RngStream_RandU01(stream);
UNPROTECT(1);
/* return sample to R */
return R_sample;
} /* end of R_RngStreams_sample() */
JNIEXPORT jdouble JNICALL Java_org_simgrid_msg_RngStream_randU01(JNIEnv *env, jobject jrngstream) {
RngStream rngstream = jrngstream_to_native(env, jrngstream);
if (!rngstream)
return 0;
return (jdouble)RngStream_RandU01(rngstream);
}
double *user_unif_rand ()
{
if (!current_stream) {
Rprintf("No stream created yet!");
return NULL;
}
rn = RngStream_RandU01(current_stream);
return &rn;
}
void get_cuckoos(int nnest, int lb[], int ub[], int dim, Nest *best, Nest *new_Nest, Nest *Nests, RngStream g1){
double beta = 3/2;
double sigma = pow((tgamma(1.0+beta) * sin(M_PI*beta/2.0) / ((tgamma(1.0+beta)/2.0) * beta * (pow(2.0,((beta-1.0)/2.0))))),(1.0/beta));
int i;
for (i = 0; i < nnest; i++){
int j;
for (j = 0; j < dim; j++){
double step = (RngStream_RandU01(g1)*sigma) / pow(fabs(RngStream_RandU01(g1)),(1/beta));
double stepsize = 0.01 * step * (best->pos[j]);
new_Nest[i].pos[j] = Nests[i].pos[j] + stepsize * RngStream_RandU01(g1);
}
}
simplebounds(nnest, dim, new_Nest, lb, ub);
}
void initializeAgents(){
alpha.fitness=sInf;
beta.fitness=sInf;
delta.fitness=sInf;
for(int i=0; i<SEARCH_AGENTS;i++){
for (int j = 0; j < dim; j++){
wolf_pack[i].pos[j]=RngStream_RandU01(g1)*(ub-lb)+lb;
}
}
}
void init(int nnest, int dim, int lb[], int ub[], Nest *Nests, RngStream g1){
int i;
for(i=0;i<nnest;i++){
int j;
for(j=0;j<dim;j++){
Nests[i].pos[j] = lb[j]+(ub[j]-lb[j])*RngStream_RandU01(g1);
}
Nests[i].fx = INFINITY;
}
}
/**
* \brief Get the next random value of a #probabilist_event_generator_t
* \param generator The #probabilist_event_generator_t
* \return the next random value
*/
double tmgr_event_generator_next_value(probabilist_event_generator_t generator)
{
switch(generator->type) {
case e_generator_uniform:
generator->next_value = (RngStream_RandU01(generator->rng_stream)
* (generator->s_uniform_parameters.max - generator->s_uniform_parameters.min))
+ generator->s_uniform_parameters.min;
break;
case e_generator_exponential:
generator->next_value = -log(RngStream_RandU01(generator->rng_stream))
/ generator->s_exponential_parameters.rate;
break;
case e_generator_weibull:
generator->next_value = generator->s_weibull_parameters.scale
* pow( -log(RngStream_RandU01(generator->rng_stream)),
1.0 / generator->s_weibull_parameters.shape );
}
return generator->next_value;
}
SEXP r_randU01 (SEXP sexp_streamCg,SEXP sexp_streamBg,SEXP sexp_streamIg,
SEXP sexp_streamAnti,SEXP sexp_streamIncPrec,
SEXP sexp_streamName)
{
SEXP sexp_result;
RngStream stream;
int i;
double rn = 0.0;
const char *name;
size_t len;
stream = (RngStream) malloc (sizeof (struct RngStream_InfoState));
if (stream == NULL) {
error("r_randU01: No more memory\n\n");
}
for (i=0; i<6; i++) {
stream->Cg[i] = REAL(sexp_streamCg)[i];
stream->Bg[i] = REAL(sexp_streamBg)[i];
stream->Ig[i] = REAL(sexp_streamIg)[i];
}
stream->Anti = INTEGER(sexp_streamAnti)[0];
stream->IncPrec = INTEGER(sexp_streamIncPrec)[0];
name = CHAR(STRING_ELT(sexp_streamName,0));
len = strlen(name);
stream->name = malloc(len+1);
if (stream->name == NULL) {
free(stream);
error("r_randU01: No more memory\n\n");
}
strncpy(stream->name, name, len+1);
rn = RngStream_RandU01(stream);
PROTECT(sexp_result = allocVector(REALSXP, 21));
for (i = 0; i < 6; ++i) {
REAL(sexp_result)[i] = (double) stream->Cg[i];
REAL(sexp_result)[i+6] = (double) stream->Bg[i];
REAL(sexp_result)[i+12] = (double) stream->Ig[i];
}
REAL(sexp_result)[18] = (int) stream->Anti;
REAL(sexp_result)[19] = (int) stream->IncPrec;
REAL(sexp_result)[20] = (double) rn;
UNPROTECT(1);
free(stream);
return sexp_result;
}
void empty_nests(int nnest, int dim, int lb[], int ub[], Nest *new_Nest, Nest *Nests, double pa, RngStream g1){
int i;
for (i = 0; i < nnest; i++){
int j;
for (j = 0; j < dim; j++){
double num = RngStream_RandU01(g1);
if(num>pa){
int rindex = rand() % nnest + 1;
double stepsize = num * Nests[rindex].pos[j] - Nests[rindex].pos[j];
new_Nest[i].pos[j] = Nests[i].pos[j] + stepsize;
}
}
}
simplebounds(nnest, dim, new_Nest, lb, ub);
}
int RngStream_RandInt (RngStream g, int i, int j)
{
return i + (int) ((j - i + 1.0) * RngStream_RandU01 (g));
}
double GWO(){
initializeAgents();
int l=0;
while(l<MI){
for(int i=0; i<SEARCH_AGENTS;i++){
double sumF = 0;
verLU(i);
for (int j = 0; j < dim; j++){
sumF = (sumF + function6(i,j));
}
//sumF=function16(i);
wolf_pack[i].fitness = sumF;
if (wolf_pack[i].fitness < alpha.fitness) {
memcpy(delta.pos, beta.pos, sizeof(beta.pos));
delta.fitness = beta.fitness;
memcpy(beta.pos, alpha.pos, sizeof(alpha.pos));
beta.fitness = alpha.fitness;
memcpy(alpha.pos, wolf_pack[i].pos, sizeof(wolf_pack[i].pos));
alpha.fitness=wolf_pack[i].fitness;
}
if (wolf_pack[i].fitness < beta.fitness && wolf_pack[i].fitness > alpha.fitness){
memcpy(delta.pos, beta.pos, sizeof(delta.pos));
delta.fitness = beta.fitness;
memcpy(beta.pos, wolf_pack[i].pos, sizeof(wolf_pack[i].pos));
beta.fitness=wolf_pack[i].fitness;
}
if (wolf_pack[i].fitness > alpha.fitness && wolf_pack[i].fitness > beta.fitness && wolf_pack[i].fitness < delta.fitness){
memcpy(delta.pos, wolf_pack[i].pos, sizeof(wolf_pack[i].pos));
delta.fitness=wolf_pack[i].fitness;
}
}
double a=2-l*((2)/MI);
for(int i=0; i<SEARCH_AGENTS;i++){
double A1[dim],A2[dim],A3[dim],D_alpha[dim],D_beta[dim],D_delta[dim],C1[dim],C2[dim],C3[dim],X1[dim],X2[dim],X3[dim];
for (int z = 0; z < dim; ++z){
A1[z]=2*a*RngStream_RandU01(g1)-a;
C1[z]=2*RngStream_RandU01(g1);
A2[z]=2*a*RngStream_RandU01(g1)-a;
C2[z]=2*RngStream_RandU01(g1);
A3[z]=2*a*RngStream_RandU01(g1)-a;
C3[z]=2*RngStream_RandU01(g1);
D_alpha[z]=fabs(C1[z]*alpha.pos[z]-wolf_pack[i].pos[z]);
D_beta[z]=fabs(C2[z]*beta.pos[z]-wolf_pack[i].pos[z]);
D_delta[z]=fabs(C3[z]*delta.pos[z]-wolf_pack[i].pos[z]);
X1[z]=alpha.pos[i]-A1[z]*D_alpha[z];
X2[z]=beta.pos[i]-A2[z]*D_beta[z];
X3[z]=delta.pos[i]-A3[z]*D_delta[z];
wolf_pack[i].pos[z]=(X1[z]+X2[z]+X3[z])/3;
}
}
l++;
}
}
double random() { return RngStream_RandU01(_stream); }
