void generate_drug () { GRand *rand; gint i, j, divisor; rand = g_rand_new (); for (i = 0; i < DRUG_NUM; i++) for (j = 0; j < CITY_NUM; j++) { drug_table[i][j].available = g_rand_boolean (rand); if (drug_table[i][j].available) { drug_table[i][j].qty = g_rand_int_range (rand, 0, 10); if (drug_table[i][j].qty > 0) divisor = drug_table[i][j].qty; else divisor = g_rand_int_range (rand, 1, 10); drug_table[i][j].price = ((double) 10 / divisor) * g_rand_double_range (rand, 0.1, 1.0) * drug_price[i]; } } g_rand_free (rand); }
static void modify_info (ExpInfo *o_info, ExpInfo *n_info) { gint k, n; *n_info = *o_info; n = g_rand_int_range (gr, 0, MAX_TRANSFORMS); for (k = 0; k < n; k++) { switch (g_rand_int_range (gr, 0, 4)) { case 0: n_info->transformSequence[g_rand_int_range (gr, 0, MAX_TRANSFORMS)] = g_rand_int_range (gr, 0, NUM_TRANSFORMS); break; case 1: n_info->source[g_rand_int_range (gr, 0, MAX_TRANSFORMS)] = g_rand_int_range (gr, 0, NUM_REGISTERS); break; case 2: n_info->control[g_rand_int_range (gr, 0, MAX_TRANSFORMS)] = g_rand_int_range (gr, 0, NUM_REGISTERS); break; case 3: n_info->dest[g_rand_int_range (gr, 0, MAX_TRANSFORMS)] = g_rand_int_range (gr, 0, NUM_REGISTERS); break; } } }
static void spread_func (gint x, gint y, guchar *dest, gint bpp, gpointer data) { SpreadParam_t *param = (SpreadParam_t*) data; gdouble angle; gint xdist, ydist; gint xi, yi; /* get random angle, x distance, and y distance */ xdist = (param->x_amount > 0 ? g_rand_int_range (param->gr, -param->x_amount, param->x_amount) : 0); ydist = (param->y_amount > 0 ? g_rand_int_range (param->gr, -param->y_amount, param->y_amount) : 0); angle = g_rand_double_range (param->gr, -G_PI, G_PI); xi = x + floor (sin (angle) * xdist); yi = y + floor (cos (angle) * ydist); /* Only displace the pixel if it's within the bounds of the image. */ if (xi >= 0 && xi < param->width && yi >= 0 && yi < param->height) { gimp_pixel_fetcher_get_pixel (param->pft, xi, yi, dest); } else /* Else just copy it */ { gimp_pixel_fetcher_get_pixel (param->pft, x, y, dest); } }
void test_field_volume_voids_planar(void) { enum { max_size = 66 }; GRand *rng = g_rand_new_with_seed(42); gsize niter = 100; for (guint iter = 0; iter < niter; iter++) { guint xres = g_rand_int_range(rng, 3, max_size); guint yres = g_rand_int_range(rng, 3, max_size); gdouble alpha = g_rand_double_range(rng, -5.0, 5.0); gdouble beta = g_rand_double_range(rng, -5.0, 5.0); gdouble base = g_rand_double_range(rng, -5.0, 5.0); GwyField *field = field_make_planar(xres, yres, alpha, beta); GwyFieldPart fpart = { 1, 1, xres-2, yres-2 }; gdouble volume, volume_expected; gwy_field_set_xreal(field, xres/sqrt(xres*yres)); gwy_field_set_yreal(field, yres/sqrt(xres*yres)); volume = gwy_field_material_volume(field, &fpart, NULL, GWY_MASK_IGNORE, FALSE, base); volume_expected = planar_field_material_volume(field, base, FALSE); gwy_assert_floatval(volume, volume_expected, 1e-9*fabs(volume_expected)); gwy_field_set_xreal(field, 1.0); gwy_field_set_yreal(field, 1.0); volume_expected = planar_field_material_volume(field, base, FALSE); volume = gwy_field_material_volume(field, &fpart, NULL, GWY_MASK_IGNORE, FALSE, base); gwy_assert_floatval(volume, volume_expected, 1e-9*fabs(volume_expected)); g_object_unref(field); } g_rand_free(rng); }
static guint32 fuzz_packet (guint8 *buf, guint32 len, guint32 stream_pos) { guint32 i; guint n_changes; #define TCP_HEADER_LENGTH 32 /* bytes; or thereabouts (include some options) */ /* Do we want to fuzz this packet? */ if (stream_pos < fuzz_start_pos) { return len; } /* Get fuzzing. Only bother fuzzing the header; fuzzing the payload is * pointless. Weight the number of changes towards having only a few changes, * since that makes them less likely to be summarily rejected. */ n_changes = random_int_poisson (n_changes_lambda); g_debug ("Making %u changes for bytes at stream position %u:", n_changes, stream_pos); for (i = 0; i < n_changes; i++) { guint32 pos = g_rand_int_range (prng, 0, MIN (len, TCP_HEADER_LENGTH)); g_debug (" • Changing byte %u.", stream_pos + pos); buf[pos] = g_rand_int_range (prng, 0, G_MAXUINT8 + 1); } return len; }
void test_field_surface_area_planar(void) { enum { max_size = 76 }; GRand *rng = g_rand_new_with_seed(42); gsize niter = 50; for (guint iter = 0; iter < niter; iter++) { guint xres = g_rand_int_range(rng, 1, max_size); guint yres = g_rand_int_range(rng, 1, max_size); gdouble alpha = g_rand_double_range(rng, -5.0, 5.0); gdouble beta = g_rand_double_range(rng, -5.0, 5.0); GwyField *field = field_make_planar(xres, yres, alpha, beta); gdouble area, area_expected; gwy_field_set_xreal(field, xres/sqrt(xres*yres)); gwy_field_set_yreal(field, yres/sqrt(xres*yres)); area = gwy_field_surface_area(field, NULL, NULL, GWY_MASK_IGNORE); area_expected = planar_field_surface_area(field); g_assert_cmpfloat(fabs(area - area_expected)/area_expected, <=, 1e-9); gwy_field_set_xreal(field, 1.0); gwy_field_set_yreal(field, 1.0); area = gwy_field_surface_area(field, NULL, NULL, GWY_MASK_IGNORE); area_expected = planar_field_surface_area(field); g_assert_cmpfloat(fabs(area - area_expected)/area_expected, <=, 1e-9); g_object_unref(field); } g_rand_free(rng); }
static void int_set_randomize(GwyIntSet *intset, GRand *rng) { guint size = g_rand_int_range(rng, 0, 20) + g_rand_int_range(rng, 0, 10); for (guint i = 0; i < size; i++) gwy_int_set_add(intset, random_integer(rng)); }
static void _gstr_randomize(GRand *r, GString *gstr) { gint i, max; g_string_set_size(gstr, 0); max = g_rand_int_range(r, 1, 15); for (i=0; i<max ; i++) { guint32 u32 = g_rand_int_range(r, 0, sizeof(random_chars)-1); g_string_append_c(gstr, random_chars[u32]); } }
static void create_info (ExpInfo *info) { gint k; for (k = 0; k < MAX_TRANSFORMS; k++) { info->transformSequence[k] = g_rand_int_range (gr, 0, NUM_TRANSFORMS); info->source[k] = g_rand_int_range (gr, 0, NUM_REGISTERS); info->control[k] = g_rand_int_range (gr, 0, NUM_REGISTERS); info->dest[k] = g_rand_int_range (gr, 0, NUM_REGISTERS); } }
void dp_deep_step_func (gpointer data, gpointer user_data) { int r1, r2, r3, r4; int start_index, end_index; DpIndivid*my_tabu; DpDeepInfo*hdeepinfo = (DpDeepInfo*)user_data; int my_id = GPOINTER_TO_INT(data) - 1; DpPopulation*trial = hdeepinfo->trial; DpIndivid*my_trial = trial->individ[my_id]; DpPopulation*population = hdeepinfo->population; DpIndivid*my_individ = population->individ[my_id]; DpRecombinationControl *recombination_control = hdeepinfo->recombination_control; int ignore_cost = hdeepinfo->hevalctrl->eval_target->ignore_cost; GRand*hrand = my_individ->hrand; r1 = ( ignore_cost == 0 ) ? population->imin : -1; do { r2 = g_rand_int_range (hrand, 0, hdeepinfo->population_size); } while ( r2 == my_id || r2 == r1 ); do { r3 = g_rand_int_range (hrand, 0, hdeepinfo->population_size); } while ( r3 == my_id || r3 == r1 || r3 == r2 ); do { r4 = g_rand_int_range (hrand, 0, hdeepinfo->population_size); } while ( r4 == my_id || r4 == r1 || r4 == r2 || r4 == r3 ); r1 = population->imin; my_tabu = population->individ[r1]; start_index = g_rand_int_range (hrand, 0, population->ind_size); end_index = population->ind_size; dp_individ_copy_values(my_trial, my_individ); my_trial->age = 0; my_trial->r1 = r1; my_trial->r2 = r2; my_trial->r3 = r3; my_trial->r4 = r4; my_trial->moves = 0; my_trial->failures = 0; my_trial->grads = 0; dp_individ_recombination(recombination_control, hrand, my_trial, population->individ[r1], population->individ[r2], population->individ[r3], population->individ[r4], start_index, end_index); dp_evaluation_individ_evaluate(hdeepinfo->hevalctrl, my_trial, my_tabu, my_id, my_tabu->cost); if ( ignore_cost == 0 && my_id == population->imin ) { if ( my_trial->cost >= my_individ->cost ) { dp_individ_copy_values(my_trial, my_individ); my_trial->age++; } } else if ( 1 != dp_evaluation_individ_compare((const void *)(&my_individ), (const void *)(&my_trial), (void*)(hdeepinfo->hevalctrl)) ) { dp_individ_copy_values(my_trial, my_individ); my_trial->age++; } }
/** * @brief Randomizes the order of the hosts objects in the collection. * Not to be used while iterating over the single hosts as it resets the * iterator. * * @param[in] hosts The hosts collection to shuffle. */ void openvas_hosts_shuffle (openvas_hosts_t *hosts) { int count; GList *new_list; GRand *rand; if (hosts == NULL) return; count = openvas_hosts_count (hosts); new_list = NULL; rand = g_rand_new (); while (count) { GList *element; /* Get element from random position [0, count[. */ element = g_list_nth (hosts->hosts, g_rand_int_range (rand, 0, count)); /* Remove it. */ hosts->hosts = g_list_remove_link (hosts->hosts, element); /* Insert it in new list */ new_list = g_list_concat (element, new_list); count--; } hosts->hosts = new_list; hosts->current = hosts->hosts; g_rand_free (rand); }
static GstFlowReturn gst_break_my_data_transform_ip (GstBaseTransform * trans, GstBuffer * buf) { GstBreakMyData *bmd = GST_BREAK_MY_DATA (trans); guint i, size; g_return_val_if_fail (gst_buffer_is_writable (buf), GST_FLOW_ERROR); GST_OBJECT_LOCK (bmd); if (bmd->skipped < bmd->skip) { i = bmd->skip - bmd->skipped; } else { i = 0; } size = GST_BUFFER_SIZE (buf); GST_LOG_OBJECT (bmd, "got buffer %p (size %u, timestamp %" G_GUINT64_FORMAT ", offset %" G_GUINT64_FORMAT "", buf, size, GST_BUFFER_TIMESTAMP (buf), GST_BUFFER_OFFSET (buf)); for (; i < size; i++) { if (g_rand_double_range (bmd->rand, 0, 1.0) <= bmd->probability) { guint8 new; if (bmd->set < 0) { new = g_rand_int_range (bmd->rand, 0, 256); } else { new = bmd->set;
static void about_dialog_reshuffle (GimpAboutDialog *dialog) { GRand *gr = g_rand_new (); gint i; for (i = 0; i < dialog->n_authors; i++) dialog->shuffle[i] = i; for (i = START_INDEX; i < dialog->n_authors; i++) { gint j = g_rand_int_range (gr, START_INDEX, dialog->n_authors); if (i != j) { gint t; t = dialog->shuffle[j]; dialog->shuffle[j] = dialog->shuffle[i]; dialog->shuffle[i] = t; } } g_rand_free (gr); }
static int semi_uniform (RLearner *rl, const unsigned int state) { double rand_value = 0.0; int action = 0; if (rl == NULL) { fprintf(stderr, "RLearner-WARNING **: RLearner *rl is NULL\n"); } else { rand_value = g_rand_double(rl->random); if (rand_value > (1.0 - EXPLORATION_THRESHOLD)) { /* Random action */ action = g_rand_int_range(rl->random, 0, rl->num_actions); } else { action = best_action(rl, state); } } return action; }
int main(int argc, char *argv[]) { GRand *rand; GTimer *timer; gint n; gint i, j; gint x = 0; rand = g_rand_new(); //创建随机数对象 for(n=0; n<20; n++) { //产生随机数并显示出来 g_print("%d\t",g_rand_int_range(rand,1,100)); } g_print("\n"); g_rand_free(rand); //释放随机数对象 //创建计时器 timer = g_timer_new(); g_timer_start(timer);//开始计时 for(i=0; i<10000; i++) for(j=0; j<3000; j++) x++;//累计 g_timer_stop(timer);//计时结束 //输出计时结果 g_print("%ld\tall:%.2f seconds was used!\n",x,g_timer_elapsed(timer,NULL)); }
static gboolean gimp_operation_dissolve_mode_process (GeglOperation *operation, void *in_buf, void *aux_buf, void *aux2_buf, void *out_buf, glong samples, const GeglRectangle *result, gint level) { gdouble opacity = GIMP_OPERATION_POINT_LAYER_MODE (operation)->opacity; gfloat *in = in_buf; gfloat *out = out_buf; gfloat *aux = aux_buf; gfloat *mask = aux2_buf; const gboolean has_mask = mask != NULL; gint x, y; for (y = result->y; y < result->y + result->height; y++) { GRand *gr = g_rand_new_with_seed (random_table[y % RANDOM_TABLE_SIZE]); /* fast forward through the rows pseudo random sequence */ for (x = 0; x < result->x; x++) g_rand_int (gr); for (x = result->x; x < result->x + result->width; x++) { gfloat value = aux[ALPHA] * opacity * 255; if (has_mask) value *= *mask; if (g_rand_int_range (gr, 0, 255) >= value) { out[0] = in[0]; out[1] = in[1]; out[2] = in[2]; out[3] = in[3]; } else { out[0] = aux[0]; out[1] = aux[1]; out[2] = aux[2]; out[3] = 1.0; } in += 4; out += 4; aux += 4; if (has_mask) mask ++; } g_rand_free (gr); } return TRUE; }
static void about_dialog_reshuffle (GimpAboutDialog *dialog) { GRand *gr = g_rand_new (); gint i; for (i = 0; i < dialog->n_authors; i++) dialog->shuffle[i] = i; /* here we rely on the authors array having Peter and Spencer first */ #define START_INDEX 2 for (i = START_INDEX; i < dialog->n_authors; i++) { gint j = g_rand_int_range (gr, START_INDEX, dialog->n_authors); if (i != j) { gint t; t = dialog->shuffle[j]; dialog->shuffle[j] = dialog->shuffle[i]; dialog->shuffle[i] = t; } } #undef START_INDEX g_rand_free (gr); }
static gboolean set_new_position(gpointer pipeline) { gint64 seek_pos = 0; GRand* rand_generator = g_rand_new(); g_debug("Starting seek :-)"); if(counter >= SEEK_COUNT){ g_rand_free (rand_generator); return FALSE; } counter++; if(volta_inicio){ seek_pos = 0; volta_inicio = FALSE; }else{ seek_pos = GST_SECOND * g_rand_int_range(rand_generator, 1, 30); volta_inicio = TRUE; } if(!gst_element_seek_simple(pipeline, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT, seek_pos)){ g_debug("Error seeking!"); g_rand_free (rand_generator); return TRUE; } g_debug("Seeked with success :-), position set is[%lld]", seek_pos / GST_SECOND); g_rand_free (rand_generator); return TRUE; }
void test_surface_set(void) { enum { max_size = 255, niter = 40 }; GRand *rng = g_rand_new_with_seed(42); for (guint iter = 0; iter < niter; iter++) { guint res = g_rand_int_range(rng, 1, max_size); GwySurface *surface = gwy_surface_new_sized(res); for (guint i = 0; i < res; i++) { GwyXYZ pt = { i, G_PI/(i + 1), -0.5*i*i }; gwy_surface_set(surface, i, pt); } for (guint k = 0; k < res; k++) { GwyXYZ pt = gwy_surface_get(surface, k); g_assert_cmpfloat(pt.x, ==, k); g_assert_cmpfloat(pt.y, ==, G_PI/(k + 1)); g_assert_cmpfloat(pt.z, ==, -0.5*k*k); } g_object_unref(surface); } g_rand_free(rng); }
gchar * fb_util_rand_alnum(guint len) { gchar *ret; GRand *rand; guint i; guint j; static const gchar chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz" "0123456789"; static const gsize charc = G_N_ELEMENTS(chars) - 1; g_return_val_if_fail(len > 0, NULL); rand = g_rand_new(); ret = g_new(gchar, len + 1); for (i = 0; i < len; i++) { j = g_rand_int_range(rand, 0, charc); ret[i] = chars[j]; } ret[len] = 0; g_rand_free(rand); return ret; }
/** * crank_bench_run_rand_int_range: (skip) * @run: A benchmark run. * @begin: Begin of range. * @end: End of range. * * Returns random integer in the range: [@begin, @end). * * Returns: A random integer in the range. */ gint32 crank_bench_run_rand_int_range (CrankBenchRun *run, const gint32 begin, const gint32 end) { return g_rand_int_range (run->random, begin, end); }
// 定时事件 // 定时事件中维持两个形状,mass和s_mass, // 当mass下落到容器的底部,释放mass // 当mass为空时,将s_mass赋给mass,再重新生成s_mass static gboolean timeout() { gint type; gboolean flag; DrawInfo *draw_info = russian_get_db_draw_info(); MatrixInfo *matrix_info = russian_get_db_matrix_info(); // 程序刚运行时,s_mass为空,需要生成 if (draw_info->s_mass==NULL) { type = g_rand_int_range(g_rand_new(), 0, MASS_TYPE_NUM); draw_info->s_mass = russian_mass_new(type); } // 当mass为空时,将s_mass赋给mass,再重新生成s_mass if (draw_info->mass==NULL) { draw_info->mass = draw_info->s_mass; russian_mass_show(draw_info->mass, DIAMOND_TYPE_MASTER); type = g_rand_int_range(g_rand_new(), 0, MASS_TYPE_NUM); russian_mass_clear(draw_info->s_mass, DIAMOND_TYPE_BACK); draw_info->s_mass = russian_mass_new(type); russian_mass_show(draw_info->s_mass, DIAMOND_TYPE_BACK); return TRUE; } // 暂停,结束时,不执行下落 if (matrix_info->pause==TRUE || matrix_info->end==TRUE) { return TRUE; } // 当mass下落到容器的底部,释放mass if (russian_mass_downMove(draw_info->mass)==FALSE) { // 释放mass g_free(draw_info->mass); draw_info->mass = NULL; // 清除容器中已成满的行 flag = russian_db_repair_maxtrix(); // 如果容器已经被填满,游戏结束 if (flag==FALSE) { russian_db_draw_gameover(); matrix_info->end = TRUE; return TRUE; } } return TRUE; }
static GstFlowReturn gst_rnd_buffer_size_drain_adapter (GstRndBufferSize * self, gboolean eos) { GstFlowReturn flow; GstBuffer *buf; guint num_bytes, avail; flow = GST_FLOW_OK; if (G_UNLIKELY (self->min > self->max)) goto bogus_minmax; do { if (self->min != self->max) { num_bytes = g_rand_int_range (self->rand, self->min, self->max); } else { num_bytes = self->min; } GST_LOG_OBJECT (self, "pulling %u bytes out of adapter", num_bytes); buf = gst_adapter_take_buffer (self->adapter, num_bytes); if (buf == NULL) { if (!eos) { GST_LOG_OBJECT (self, "not enough bytes in adapter"); break; } avail = gst_adapter_available (self->adapter); if (avail == 0) break; if (avail < self->min) { GST_WARNING_OBJECT (self, "discarding %u bytes at end (min=%u)", avail, self->min); gst_adapter_clear (self->adapter); break; } buf = gst_adapter_take_buffer (self->adapter, avail); g_assert (buf != NULL); } flow = gst_pad_push (self->srcpad, buf); } while (flow == GST_FLOW_OK); return flow; /* ERRORS */ bogus_minmax: { GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS, ("The minimum buffer size is smaller than the maximum buffer size."), ("buffer sizes: max=%d, min=%d", self->min, self->max)); return GST_FLOW_ERROR; } }
int main(int argc, char **argv) { int npoints = 100; GRand *rng = g_rand_new (); pointlist2d_t *candidates = pointlist2d_new (npoints); for (int i=0; i<npoints; i++) { candidates->points[i].x = g_rand_double_range (rng, 0, 100); candidates->points[i].y = g_rand_double_range (rng, 0, 100); } for (int i=0; i<5000000; i++) { pointlist2d_t *a = pointlist2d_new (g_rand_int_range (rng, 3, npoints / 3)); pointlist2d_t *b = pointlist2d_new (g_rand_int_range (rng, 3, npoints / 3)); for (int j=0; j<a->npoints; j++) { a->points[j] = candidates->points[g_rand_int_range (rng, 0, npoints)]; } for (int j=0; j<b->npoints; j++) { b->points[j] = candidates->points[g_rand_int_range (rng, 0, npoints)]; } pointlist2d_t *ah = convexhull_graham_scan_2d (a); if (ah) { pointlist2d_t *bh = convexhull_graham_scan_2d (b); if (bh) { pointlist2d_t *isect = geom_convex_polygon_convex_polygon_intersect_2d (ah, bh); if (isect) pointlist2d_free (isect); pointlist2d_free (bh); } pointlist2d_free (ah); } pointlist2d_free (a); pointlist2d_free (b); } return 0; }
void test_field_part_intersect(void) { enum { max_size = 40, niter = 500, n = 10000 }; GRand *rng = g_rand_new_with_seed(42); for (guint iter = 0; iter < niter; iter++) { GwyFieldPart result = { g_rand_int_range(rng, 0, max_size), g_rand_int_range(rng, 0, max_size), g_rand_int_range(rng, 0, max_size), g_rand_int_range(rng, 0, max_size), }; GwyFieldPart otherpart = { g_rand_int_range(rng, 0, max_size), g_rand_int_range(rng, 0, max_size), g_rand_int_range(rng, 0, max_size), g_rand_int_range(rng, 0, max_size), }; GwyFieldPart fpart = result; gboolean intersecting = gwy_field_part_intersect(&result, &otherpart); for (guint k = 0; k < n; k++) { guint j = g_rand_int_range(rng, 0, 2*max_size); guint i = g_rand_int_range(rng, 0, 2*max_size); gboolean in_fpart = (j >= fpart.col && j - fpart.col < fpart.width && i >= fpart.row && i - fpart.row < fpart.height); gboolean in_otherpart = (j >= otherpart.col && j - otherpart.col < otherpart.width && i >= otherpart.row && i - otherpart.row < otherpart.height); gboolean in_result = (j >= result.col && j - result.col < result.width && i >= result.row && i - result.row < result.height); g_assert_cmpuint(in_result, ==, in_fpart && in_otherpart); g_assert(intersecting || !in_result); } } g_rand_free(rng); }
static void on_monitors_changed (MetaScreen *screen, MetaPlugin *plugin) { MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin); int i, n; GRand *rand = g_rand_new_with_seed (123456); clutter_actor_destroy_all_children (self->priv->background_group); n = meta_screen_get_n_monitors (screen); for (i = 0; i < n; i++) { MetaRectangle rect; ClutterActor *background_actor; MetaBackground *background; ClutterColor color; meta_screen_get_monitor_geometry (screen, i, &rect); background_actor = meta_background_actor_new (screen, i); clutter_actor_set_position (background_actor, rect.x, rect.y); clutter_actor_set_size (background_actor, rect.width, rect.height); /* Don't use rand() here, mesa calls srand() internally when parsing the driconf XML, but it's nice if the colors are reproducible. */ clutter_color_init (&color, g_rand_int_range (rand, 0, 255), g_rand_int_range (rand, 0, 255), g_rand_int_range (rand, 0, 255), 255); background = meta_background_new (screen); meta_background_set_color (background, &color); meta_background_actor_set_background (META_BACKGROUND_ACTOR (background_actor), background); g_object_unref (background); clutter_actor_add_child (self->priv->background_group, background_actor); } g_rand_free (rand); }
static void _append_random_chars (gchar *d, const char *chars, guint n) { size_t len = strlen (chars); gchar *p = d + strlen(d); for (guint i=0; i<n ;i++) *(p++) = chars [g_rand_int_range (prng, 0, len)]; *p = '\0'; }
void test_field_part_union(void) { enum { max_size = 40, niter = 500, n = 10000 }; GRand *rng = g_rand_new_with_seed(42); for (guint iter = 0; iter < niter; iter++) { GwyFieldPart result = { g_rand_int_range(rng, 0, max_size), g_rand_int_range(rng, 0, max_size), g_rand_int_range(rng, 0, max_size), g_rand_int_range(rng, 0, max_size), }; GwyFieldPart otherpart = { g_rand_int_range(rng, 0, max_size), g_rand_int_range(rng, 0, max_size), g_rand_int_range(rng, 0, max_size), g_rand_int_range(rng, 0, max_size), }; GwyFieldPart fpart = result; gwy_field_part_union(&result, &otherpart); for (guint k = 0; k < n; k++) { guint j = g_rand_int_range(rng, 0, 2*max_size); guint i = g_rand_int_range(rng, 0, 2*max_size); gboolean in_x = ((j >= fpart.col || j >= otherpart.col) && (j < fpart.col + fpart.width || j < otherpart.col + otherpart.width)); gboolean in_y = ((i >= fpart.row || i >= otherpart.row) && (i < fpart.row + fpart.height || i < otherpart.row + otherpart.height)); gboolean in_result = (j >= result.col && j - result.col < result.width && i >= result.row && i - result.row < result.height); g_assert_cmpuint(in_result, ==, in_x && in_y); } } g_rand_free(rng); }
static void futz_row (void) { gint i; GtkTreePath *path; GtkTreeIter iter; GtkTreeIter iter2; i = g_rand_int_range (grand, 0, gtk_tree_model_iter_n_children (model, NULL)); path = gtk_tree_path_new (); gtk_tree_path_append_index (path, i); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); if (gtk_tree_selection_iter_is_selected (selection, &iter)) return; switch (g_rand_int_range (grand, 0, 3)) { case 0: /* insert */ gtk_list_store_insert_after (GTK_LIST_STORE (model), &iter2, &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter2, TEXT_COLUMN, words[g_rand_int_range (grand, 0, NUM_WORDS)], -1); break; case 1: /* delete */ if (gtk_tree_model_iter_n_children (model, NULL) == 0) return; gtk_list_store_remove (GTK_LIST_STORE (model), &iter); break; case 2: /* modify */ return; if (gtk_tree_model_iter_n_children (model, NULL) == 0) return; gtk_list_store_set (GTK_LIST_STORE (model), &iter, TEXT_COLUMN, words[g_rand_int_range (grand, 0, NUM_WORDS)], -1); break; } }
void gw_flashcardstore_trim (GwFlashCardStore *store, gint max) { //Sanity Checks if (store == NULL) return; if (max < 1) return; //Declarations GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter; gboolean valid; gint children; gchar *path_string; GRand *random; gint position; gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE (store), GW_FLASHCARDSTORE_COLUMN_WEIGHT, GTK_SORT_DESCENDING); model = GTK_TREE_MODEL (store); random = g_rand_new (); children = gtk_tree_model_iter_n_children (model, NULL); if (random != NULL) { while (children > max && children > 0) { position = g_rand_int_range (random, 0, children); path_string = g_strdup_printf ("%d", position); if (path_string != NULL) { valid = gtk_tree_model_get_iter_from_string (model, &iter, path_string); if (valid) { gtk_tree_model_get (model, &iter, GW_FLASHCARDSTORE_COLUMN_TREE_PATH, &path, -1); if (path != NULL) gtk_tree_path_free (path); path = NULL; gtk_list_store_remove (GTK_LIST_STORE (store), &iter); } g_free (path_string); path_string = NULL; } children--; } g_rand_free (random); random = NULL; } gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE (store), GW_FLASHCARDSTORE_COLUMN_ORDER, GTK_SORT_ASCENDING); gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE (store), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, GTK_SORT_ASCENDING); }