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 gimp_operation_dissolve_mode_class_init (GimpOperationDissolveModeClass *klass) { GeglOperationClass *operation_class; GeglOperationPointComposer3Class *point_composer_class; GRand *gr; gint i; operation_class = GEGL_OPERATION_CLASS (klass); point_composer_class = GEGL_OPERATION_POINT_COMPOSER3_CLASS (klass); gegl_operation_class_set_keys (operation_class, "name", "gimp:dissolve-mode", "description", "GIMP dissolve mode operation", "categories", "compositors", NULL); operation_class->prepare = gimp_operation_dissolve_mode_prepare; point_composer_class->process = gimp_operation_dissolve_mode_process; /* generate a table of random seeds */ gr = g_rand_new_with_seed (314159265); for (i = 0; i < RANDOM_TABLE_SIZE; i++) random_table[i] = g_rand_int (gr); g_rand_free (gr); }
void test_field_process_quarters_unmasked_border(void) { enum { max_size = 15, niter = 100 }; gdouble eps = 1e-12; GRand *rng = g_rand_new_with_seed(42); 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); guint width = g_rand_int_range(rng, 1, xres+1); guint height = g_rand_int_range(rng, 1, yres+1); guint col = g_rand_int_range(rng, 0, xres-width+1); guint row = g_rand_int_range(rng, 0, yres-height+1); GwyFieldPart fpart = { col, row, width, height }; GwyField *field = gwy_field_new_sized(xres, yres, FALSE); gboolean useallfunc = g_rand_boolean(rng); field_randomize(field, rng); gdouble result = 0.0; gwy_field_process_quarters(field, &fpart, NULL, 0, TRUE, sum_quarters, useallfunc ? sum_allquarters : NULL, &result); gdouble reference = 0.0; for (guint i = 0; i < height; i++) { for (guint j = 0; j < width; j++) { reference += 4.0*gwy_field_index(field, col + j, row + i); } } gwy_assert_floatval(result, reference, eps); g_object_unref(field); } g_rand_free(rng); }
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 rt_pattern* rt_pattern_new(void) { rt_pattern* rtpat = malloc(sizeof(*rtpat)); MESSAGE("new rt_pattern...\n"); if (!rtpat) goto fail0; rtpat->rnd = g_rand_new_with_seed((guint32)time(NULL)); if (!rtpat->rnd) goto fail1; rtpat->playing = 0; rtpat->triggered = 0; /* rtpat->seedtype = SEED_TIME_SYS;*/ rtpat->start_tick = rtpat->end_tick = 0; rtpat->index = rtpat->loop_length = 0; rtpat->width_min = rtpat->width_max = 0; rtpat->height_min = rtpat->height_max = 0; rtpat->events = 0; rtpat->evlast = 0; rtpat->evout = 0; return rtpat; fail1: free(rtpat); fail0: MESSAGE("out of memory for rt_pattern\n"); return 0; }
static void _random2_distribution (GPtrArray *points, AranSolver2d *solver) { guint i; PointAccum *point; GRand *rand = g_rand_new_with_seed (_random_seed); point = point_accum_alloc (TRUE, NULL); for (i=0; i<np; i++) { #ifdef VSG_HAVE_MPI if (i%_flush_interval == 0) { aran_solver2d_migrate_flush (solver); if (i%(_flush_interval*10) == 0) { if (_verbose && rk == 0) g_printerr ("%d: contiguous dist before %dth point\n", rk, i); aran_solver2d_distribute_contiguous_leaves (solver); } } #endif /* VSG_HAVE_MPI */ point->vector.x = g_rand_double_range (rand, -R, R);; point->vector.y = g_rand_double_range (rand, -R, R);; point->density = 1.; point->accum = 0.; point->id = i; if (check) memcpy (&check_points[i], point, sizeof (PointAccum)); if (aran_solver2d_insert_point_local (solver, point)) { if (i % 10000 == 0 && _verbose) g_printerr ("%d: insert %dth point\n", rk, i); point = point_accum_alloc (TRUE, NULL); } #ifdef VSG_HAVE_MPI if (i%(_flush_interval*10) == 0) { if (_verbose && rk == 0) g_printerr ("%d: contiguous dist before %dth point\n", rk, i); aran_solver2d_distribute_contiguous_leaves (solver); } #endif /* VSG_HAVE_MPI */ } point_accum_destroy (point, TRUE, NULL); #ifdef VSG_HAVE_MPI aran_solver2d_distribute_contiguous_leaves (solver); #endif /* VSG_HAVE_MPI */ g_rand_free (rand); }
void test_int_set_assign(void) { GRand *rng = g_rand_new_with_seed(42); gsize niter = 20; for (guint iter = 0; iter < niter; iter++) { GwyIntSet *original = gwy_int_set_new(), *copy = gwy_int_set_new(); int_set_randomize(original, rng); guint counter = 0, xcounter = 0; g_signal_connect_swapped(copy, "assigned", G_CALLBACK(record_signal), &counter); g_signal_connect_swapped(copy, "added", G_CALLBACK(record_signal), &xcounter); g_signal_connect_swapped(copy, "removed", G_CALLBACK(record_signal), &xcounter); g_signal_connect_swapped(original, "added", G_CALLBACK(record_signal), &xcounter); g_signal_connect_swapped(original, "removed", G_CALLBACK(record_signal), &xcounter); g_signal_connect_swapped(original, "assigned", G_CALLBACK(record_signal), &xcounter); gwy_int_set_assign(copy, original); int_set_assert_order(copy); int_set_assert_equal(copy, original); g_assert_cmpuint(counter, ==, 1); g_assert_cmpuint(xcounter, ==, 0); g_object_unref(copy); g_object_unref(original); } g_rand_free(rng); }
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); }
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); }
static void _random2_fill (AranSolver3d *solver) { guint64 i; PointAccum *point; GRand *rand = g_rand_new_with_seed (_random_seed); point = point_accum_alloc (TRUE, NULL); for (i=0; i<np; i++) { #ifdef VSG_HAVE_MPI if (i%_flush_interval == 0) { aran_solver3d_migrate_flush (solver); if (i%(_flush_interval*10) == 0) { if (_verbose && rk == 0) g_printerr ("%d: contiguous dist before %luth point\n", rk, i); aran_solver3d_distribute_contiguous_leaves (solver); _flush_interval *=2; } } #endif /* VSG_HAVE_MPI */ point->vector.x = g_rand_double_range (rand, -R, R);; point->vector.y = g_rand_double_range (rand, -R, R);; point->vector.z = g_rand_double_range (rand, -R, R);; point->density = 1./np; point->field = VSG_V3D_ZERO; point->id = i; /* if (i == 3) point->density = 0.; */ /* if (i == 4) point->density = 0.; */ /* if (i == 5) point->density = 0.; */ if (check) memcpy (&check_points[i], point, sizeof (PointAccum)); if (aran_solver3d_insert_point_local (solver, point)) { if (i % 10000 == 0 && _verbose) g_printerr ("%d: insert %luth point\n", rk, i); point = point_accum_alloc (TRUE, NULL); } } point_accum_destroy (point, TRUE, NULL); #ifdef VSG_HAVE_MPI aran_solver3d_migrate_flush (solver); aran_solver3d_distribute_contiguous_leaves (solver); #endif /* VSG_HAVE_MPI */ g_rand_free (rand); }
void setup (void) { factory = goo_ti_component_factory_get_instance (); component = goo_component_factory_get_component (factory, GOO_TI_H263_DECODER); rnd = g_rand_new_with_seed (time (0)); return; }
/* UV sphere fill */ static void _uvsphere_fill (AranSolver3d *solver) { gint i; PointAccum *point; VsgVector3d lb, ub; GRand *rand = g_rand_new_with_seed (_random_seed); gdouble r; aran_solver3d_get_bounds (solver, &lb, &ub); r = MIN (lb.x, ub.x); point = point_accum_alloc (TRUE, NULL); for (i=0; i< np; i++) { gdouble theta, phi; theta = g_rand_double_range (rand, 0.01 * G_PI, 0.99 * G_PI); phi = g_rand_double_range (rand, 0., 2.*G_PI); vsg_vector3d_from_spherical (&point->vector, r, theta, phi); point->density = 1.; point->field = VSG_V3D_ZERO; point->id = i; if (check) memcpy (&check_points[i], point, sizeof (PointAccum)); if (aran_solver3d_insert_point_local (solver, point)) { if (i % 10000 == 0 && _verbose) g_printerr ("%d: insert %dth point\n", rk, i); point = point_accum_alloc (TRUE, NULL); } #ifdef VSG_HAVE_MPI if (i%(_flush_interval*10) == 0) { if (_verbose && rk == 0) g_printerr ("%d: contiguous dist before %dth point\n", rk, i); aran_solver3d_distribute_contiguous_leaves (solver); _flush_interval *=2; } #endif /* VSG_HAVE_MPI */ } point_accum_destroy (point, TRUE, NULL); #ifdef VSG_HAVE_MPI aran_solver3d_distribute_contiguous_leaves (solver); #endif /* VSG_HAVE_MPI */ g_rand_free (rand); }
gboolean gimp_operation_dissolve_mode_process_pixels (gfloat *in, gfloat *aux, gfloat *mask, gfloat *out, gfloat opacity, glong samples, const GeglRectangle *result, gint level) { 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; }
void test_field_process_quarters_masked_noborder(void) { enum { max_size = 15, niter = 100 }; gdouble eps = 1e-12; GRand *rng = g_rand_new_with_seed(42); 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); guint width = g_rand_int_range(rng, 1, xres+1); guint height = g_rand_int_range(rng, 1, yres+1); guint col = g_rand_int_range(rng, 0, xres-width+1); guint row = g_rand_int_range(rng, 0, yres-height+1); GwyFieldPart fpart = { col, row, width, height }; GwyField *field = gwy_field_new_sized(xres, yres, FALSE); gboolean useallfunc = g_rand_boolean(rng); field_randomize(field, rng); GwyMaskField *mask = random_mask_field_prob(xres, yres, rng, 0.5); gdouble result = 0.0, result0 = 0.0, result1 = 0.0; gwy_field_process_quarters(field, &fpart, mask, GWY_MASK_IGNORE, FALSE, sum_quarters, useallfunc ? sum_allquarters : NULL, &result); gwy_field_process_quarters(field, &fpart, mask, GWY_MASK_EXCLUDE, FALSE, sum_quarters, useallfunc ? sum_allquarters : NULL, &result0); gwy_field_process_quarters(field, &fpart, mask, GWY_MASK_INCLUDE, FALSE, sum_quarters, useallfunc ? sum_allquarters : NULL, &result1); gdouble reference = 0.0, reference0 = 0.0, reference1 = 0.0; for (guint i = 0; i < height; i++) { for (guint j = 0; j < width; j++) { guint wh = (col + j > 0) + (col + j < xres-1); guint wv = (row + i > 0) + (row + i < yres-1); gdouble v = wh*wv*gwy_field_index(field, col + j, row + i); reference += v; if (gwy_mask_field_get(mask, col + j, row + i)) reference1 += v; else reference0 += v; } } gwy_assert_floatval(result, reference, eps); gwy_assert_floatval(result0, reference0, eps); gwy_assert_floatval(result1, reference1, eps); g_object_unref(mask); g_object_unref(field); } g_rand_free(rng); }
END_TEST START_TEST(test_atree_max_value) { ATree *at; gint result; gint key_a; gint data_a; gint key_b; gint data_b; gint *max; GRand *random; at = a_tree_new(); if (at == NULL) { ck_abort_msg ("Failed to create ATree\n"); } else { random = g_rand_new_with_seed( (guint32) at ); key_a = g_rand_int( random ); data_a = g_rand_int( random ); key_b = g_rand_int( random ); data_b = g_rand_int( random ); result = atree_insert( at, GINT_TO_POINTER(&key_a), GINT_TO_POINTER(&data_a) ); ck_assert_int_eq( result, 0 ); result = atree_insert( at, GINT_TO_POINTER(&key_b), GINT_TO_POINTER(&data_b) ); ck_assert_int_eq( result, 0 ); max = atree_max_value( at ); if (max == NULL) { ck_abort_msg ("maximum values is NULL\n"); } else { if (key_a > key_b) { ck_assert_int_eq( *max, data_a ); } else { ck_assert_int_eq( *max, data_b ); } } a_tree_destroy( at ); } }
static void _random_fill (AranSolver3d *solver) { guint i; PointAccum *point; GRand *rand = g_rand_new_with_seed (_random_seed); for (i=0; i<np; i++) { PointAccum tmp; #ifdef VSG_HAVE_MPI if (i%_flush_interval == 0) { aran_solver3d_migrate_flush (solver); if (i%(_flush_interval*10) == 0) { if (_verbose && rk == 0) g_printerr ("%d: contiguous dist before %dth point\n", rk, i); aran_solver3d_distribute_contiguous_leaves (solver); _flush_interval *=2; } } #endif /* VSG_HAVE_MPI */ tmp.vector.x = g_rand_double_range (rand, -R, R);; tmp.vector.y = g_rand_double_range (rand, -R, R);; tmp.vector.z = g_rand_double_range (rand, -R, R);; tmp.density = 1.; tmp.field = VSG_V3D_ZERO; tmp.id = i; if (check) memcpy (&check_points[i], &tmp, sizeof (PointAccum)); if (i%sz != rk) continue; if (i % 10000 == 0 && _verbose) g_printerr ("%d: insert %dth point\n", rk, i); point = point_accum_alloc (TRUE, NULL); memcpy (point, &tmp, sizeof (PointAccum)); aran_solver3d_insert_point (solver, point); } #ifdef VSG_HAVE_MPI aran_solver3d_migrate_flush (solver); aran_solver3d_distribute_contiguous_leaves (solver); #endif /* VSG_HAVE_MPI */ g_rand_free (rand); }
void _random_fill (VsgPRTree2d *tree, guint np) { gint i; Pt *pt; VsgVector2d lb, ub; GRand *rand = g_rand_new_with_seed (_random_seed); vsg_prtree2d_get_bounds (tree, &lb, &ub); _ref_count = 0; for (i=0; i< np; i++) { gdouble x1, y1; gint c; x1 = g_rand_double_range (rand, lb.x, ub.x); y1 = g_rand_double_range (rand, lb.y, ub.y); c = i+1; _ref_count += c; if (i%_flush_interval == 0) { vsg_prtree2d_migrate_flush (tree); if (i%(_flush_interval*10) == 0) { if (_verbose && rk == 0) g_printerr ("%d: contiguous dist before %dth point\n", rk, i); _distribute (tree); } } if (i%sz != rk) continue; if (i % 10000 == 0 && _verbose) g_printerr ("%d: insert %dth point\n", rk, i); pt = pt_alloc (TRUE, NULL); pt->vector.x = x1; pt->vector.y = y1; pt->weight = c; vsg_prtree2d_insert_point (tree, pt); } vsg_prtree2d_migrate_flush (tree); _distribute (tree); g_rand_free (rand); }
static void random_fill (VsgPRTree3d *tree, guint np) { gint i; VsgVector3d *pt; Sphere *c; VsgVector3d lb, ub; GRand *rand = g_rand_new_with_seed (_random_seed); vsg_prtree3d_get_bounds (tree, &lb, &ub); for (i=0; i< np; i++) { gdouble x1, x2, y1, y2, z1, z2, r; x1 = g_rand_double_range (rand, lb.x, ub.x); y1 = g_rand_double_range (rand, lb.y, ub.y); z1 = g_rand_double_range (rand, lb.z, ub.z); x2 = g_rand_double_range (rand, lb.x, ub.x); y2 = g_rand_double_range (rand, lb.y, ub.y); z2 = g_rand_double_range (rand, lb.z, ub.z); r = g_rand_double_range (rand, 0., 0.1); if (i%_flush_interval == 0) vsg_prtree3d_migrate_flush (tree); if (i%sz != rk) continue; if (i % 10000 == 0 && _verbose) g_printerr ("%d: insert %dth point\n", rk, i); pt = pt_alloc (TRUE, NULL); pt->x = x1; pt->y = y1; pt->z = z1; vsg_prtree3d_insert_point (tree, pt); if (_put_regions) { c = rg_alloc (TRUE, NULL); c->center.x = x2; c->center.y = y2; c->center.z = z2; c->radius = r; vsg_prtree3d_insert_region (tree, c); } /* g_printerr ("%d: %d\n", rk, i); */ } vsg_prtree3d_migrate_flush (tree); g_rand_free (rand); }
char get_rand_ascii_print(void) { GRand *rand ; struct timeval tv ; gettimeofday(&tv, NULL) ; g_usleep(tv.tv_usec % 256) ; rand = g_rand_new_with_seed((guint32) tv.tv_usec); return (char) ((g_rand_int(rand) % 26) + 97) ; }
void field_volume_masked_one(GwyFieldVolumeMethod method) { 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); GwyField *field = gwy_field_new_sized(xres, yres, FALSE); field_randomize(field, rng); guint width = g_rand_int_range(rng, 1, xres+1); guint height = g_rand_int_range(rng, 1, yres+1); guint col = g_rand_int_range(rng, 0, xres-width+1); guint row = g_rand_int_range(rng, 0, yres-height+1); GwyFieldPart fpart = { col, row, width, height }; GwyMaskField *mask = random_mask_field(xres, yres, rng); gwy_field_set_xreal(field, xres/sqrt(xres*yres)); gwy_field_set_yreal(field, yres/sqrt(xres*yres)); gdouble volume_include, volume_exclude, volume_ignore; volume_include = gwy_field_volume(field, &fpart, mask, GWY_MASK_INCLUDE, method); volume_exclude = gwy_field_volume(field, &fpart, mask, GWY_MASK_EXCLUDE, method); volume_ignore = gwy_field_volume(field, &fpart, mask, GWY_MASK_IGNORE, method); gwy_assert_floatval(volume_include + volume_exclude, volume_ignore, 1e-9*volume_ignore); gwy_field_set_xreal(field, 1.0); gwy_field_set_yreal(field, 1.0); volume_include = gwy_field_volume(field, &fpart, mask, GWY_MASK_INCLUDE, method); volume_exclude = gwy_field_volume(field, &fpart, mask, GWY_MASK_EXCLUDE, method); volume_ignore = gwy_field_volume(field, &fpart, mask, GWY_MASK_IGNORE, method); gwy_assert_floatval(volume_include + volume_exclude, volume_ignore, 1e-9*volume_ignore); g_object_unref(mask); g_object_unref(field); } g_rand_free(rng); }
int SSproblem_definition( SS *problem, int b1, int b2, double timelimit, int combine_method, int njobs, int nmachines, Job *jobarray, int lowerbound) { int i, val = 0; REFSET *temp_rs = NULL; P *temp_p = NULL; /*initialize scatter search data structure */ SS_init(problem, b1, b2, timelimit); problem->combine_method = combine_method; problem->nmachines = nmachines; problem->njobs = njobs; problem->lowerbound = lowerbound; problem->upperbound = INT_MAX; /* Initialize pool */ problem->p = CC_SAFE_MALLOC(1, P); CCcheck_NULL_2(problem->p, "Failed to allocate memory to problem->p"); temp_p = problem->p; P_init(temp_p); /* Initialize refset */ problem->rs = CC_SAFE_MALLOC(1, REFSET); CCcheck_NULL_2(problem->rs, "Failed to allocate memory to problem->rs"); temp_rs = problem->rs; REFSET_init(temp_rs); /* Initialize Jobarray of scatter search data structure */ problem->jobarray = CC_SAFE_MALLOC(njobs, Job *); CCcheck_NULL_2(problem->jobarray, "Failed to allocate memory"); for (i = 0; i < njobs; i++) { problem->jobarray[i] = jobarray + i ; } problem->random = g_rand_new_with_seed(48654642); CCcheck_NULL_2(problem->random, "Failed in g_rand_new_with_seed"); CLEAN: if (val) { SS_free(problem); } return val; }
void test_field_surface_area_masked(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); GwyField *field = gwy_field_new_sized(xres, yres, FALSE); field_randomize(field, rng); guint width = g_rand_int_range(rng, 1, xres+1); guint height = g_rand_int_range(rng, 1, yres+1); guint col = g_rand_int_range(rng, 0, xres-width+1); guint row = g_rand_int_range(rng, 0, yres-height+1); GwyFieldPart fpart = { col, row, width, height }; GwyMaskField *mask = random_mask_field(xres, yres, rng); gwy_field_set_xreal(field, xres/sqrt(xres*yres)); gwy_field_set_yreal(field, yres/sqrt(xres*yres)); gdouble area_include, area_exclude, area_ignore; area_include = gwy_field_surface_area(field, &fpart, mask, GWY_MASK_INCLUDE); area_exclude = gwy_field_surface_area(field, &fpart, mask, GWY_MASK_EXCLUDE); area_ignore = gwy_field_surface_area(field, &fpart, mask, GWY_MASK_IGNORE); g_assert_cmpfloat(fabs(area_include + area_exclude - area_ignore)/area_ignore, <=, 1e-9); gwy_field_set_xreal(field, 1.0); gwy_field_set_yreal(field, 1.0); area_include = gwy_field_surface_area(field, &fpart, mask, GWY_MASK_INCLUDE); area_exclude = gwy_field_surface_area(field, &fpart, mask, GWY_MASK_EXCLUDE); area_ignore = gwy_field_surface_area(field, &fpart, mask, GWY_MASK_IGNORE); g_assert_cmpfloat(fabs(area_include + area_exclude - area_ignore)/area_ignore, <=, 1e-9); g_object_unref(mask); g_object_unref(field); } g_rand_free(rng); }
void test_field_mean(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 mean, mean_expected; mean = gwy_field_mean_full(field); mean_expected = 0.5*(alpha + beta); gwy_assert_floatval(mean, mean_expected, 1e-9*fabs(mean_expected)); field_randomize(field, rng); guint width = g_rand_int_range(rng, 1, xres+1); guint height = g_rand_int_range(rng, 1, yres+1); guint col = g_rand_int_range(rng, 0, xres-width+1); guint row = g_rand_int_range(rng, 0, yres-height+1); GwyFieldPart fpart = { col, row, width, height }; GwyMaskField *mask = random_mask_field(xres, yres, rng); guint m = gwy_mask_field_part_count(mask, &fpart, TRUE); guint n = gwy_mask_field_part_count(mask, &fpart, FALSE); gdouble mean_include = gwy_field_mean(field, &fpart, mask, GWY_MASK_INCLUDE); gdouble mean_exclude = gwy_field_mean(field, &fpart, mask, GWY_MASK_EXCLUDE); gdouble mean_ignore = gwy_field_mean(field, &fpart, mask, GWY_MASK_IGNORE); if (isnan(mean_include)) { g_assert_cmpuint(m, ==, 0); gwy_assert_floatval(mean_exclude, mean_ignore, 1e-9*fabs(mean_ignore)); } else if (isnan(mean_exclude)) { g_assert_cmpuint(n, ==, 0); gwy_assert_floatval(mean_include, mean_ignore, 1e-9*fabs(mean_ignore)); } else {
static void _zmq2agent_worker (struct _zmq2agent_ctx_s *ctx) { /* XXX(jfs): a dedicated PRNG avoids locking the glib's PRNG for each call (such global locks are present in the GLib) and opening it with a seed from the glib's PRNG avoids syscalls to the special file /dev/urandom */ GRand *r = g_rand_new_with_seed (g_random_int ()); gint64 last_debug = oio_ext_monotonic_time (); zmq_pollitem_t pi[2] = { {ctx->zpull, -1, ZMQ_POLLIN, 0}, {ctx->zagent, -1, ZMQ_POLLIN, 0}, }; for (gboolean run = TRUE; run ;) { int rc = zmq_poll (pi, 2, 1000); if (rc < 0) { int err = zmq_errno(); if (err != ETERM && err != EINTR) GRID_WARN("ZMQ poll error : (%d) %s", err, zmq_strerror(err)); if (err != EINTR) break; } if (pi[1].revents) _zmq2agent_receive_acks (ctx); _retry_events (ctx); if (pi[0].revents) run = _zmq2agent_receive_events (r, ctx); /* Periodically write stats in the log */ gint64 now = oio_ext_monotonic_time (); if ((now - last_debug) > 2 * G_TIME_SPAN_MINUTE) { GRID_INFO("ZMQ2AGENT recv=%"G_GINT64_FORMAT" sent=%"G_GINT64_FORMAT " ack=%"G_GINT64_FORMAT"+%"G_GINT64_FORMAT" queue=%u", ctx->q->counter_received, ctx->q->counter_sent, ctx->q->counter_ack, ctx->q->counter_ack_notfound, ctx->q->gauge_pending); last_debug = now; } } g_rand_free (r); GRID_INFO ("Thread stopping [NOTIFY-ZMQ2AGENT]"); }
static GstStateChangeReturn gst_rnd_buffer_size_change_state (GstElement * element, GstStateChange transition) { GstRndBufferSize *self = GST_RND_BUFFER_SIZE (element); GstStateChangeReturn ret; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: self->offset = 0; if (!self->rand) { self->rand = g_rand_new_with_seed (self->seed); } break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: if (self->rand) { g_rand_free (self->rand); self->rand = NULL; } break; case GST_STATE_CHANGE_READY_TO_NULL: if (self->adapter) { g_object_unref (self->adapter); self->adapter = NULL; } break; default: break; } return ret; }
static gboolean on_window_draw (GtkWidget *widget, cairo_t *cr) { GRand *rand = g_rand_new_with_seed(0); int i; int width, height; width = gtk_widget_get_allocated_width (widget); height = gtk_widget_get_allocated_height (widget); ensure_resources (cairo_get_target (cr)); cairo_set_source_rgb(cr, 1, 1, 1); cairo_paint(cr); cairo_set_source_rgb(cr, 0, 0, 0); cairo_set_line_width(cr, 1.0); cairo_rectangle (cr, 0.5, 0.5, width - 1, height - 1); cairo_stroke (cr); for(i = 0; i < load_factor * 150; i++) { int source = g_rand_int_range(rand, 0, 255); double phi = g_rand_double_range(rand, 0, 2 * M_PI) + angle; double r = g_rand_double_range(rand, 0, width / 2 - RADIUS); int x, y; int source_x = (source % 16) * DIAMETER; int source_y = (source / 16) * DIAMETER; x = round(width / 2 + r * cos(phi) - RADIUS); y = round(height / 2 - r * sin(phi) - RADIUS); cairo_set_source_surface(cr, source_surface, x - source_x, y - source_y); cairo_rectangle(cr, x, y, DIAMETER, DIAMETER); cairo_fill(cr); } g_rand_free(rand); return FALSE; }
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); }
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); }
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); }
BMI_Model * avulsion_set_variance (BMI_Model * self, double variance) { BMI_Model *p = (BMI_Model *) self; p->variance = variance; { Sed_riv r = sed_cube_borrow_nth_river (p->p, 0); Avulsion_st* data; data = avulsion_new ( (p->seed==0)?g_rand_new():g_rand_new_with_seed(p->seed), variance); eh_require (data); sed_river_set_avulsion_data (r, data); //sed_river_avulsion_data (r)->std_dev = variance; } return self; }