コード例 #1
0
/*!
 * interpolate_qls test.
 *
 * This function test the interpolation function.
 */
void interpolate_qls_test(){
  int i, status;
  double a0, f0, df0, a1, f1, df1, a;
  double quad_tol = 1.e-6;

  fprintf( stdout, " interpolate_qls: ");
  status = 0;

  /* First test the quadratic: it should be exact */
  for( i=0; i<10; i++){
    if( rand() %2 == 0 ){
      a0 = rand_double( 1., 5.);
      a1 = rand_double( -5., -1.);
    }else{
      a0 = rand_double( -5., -1.);
      a1 = rand_double( 1., 5.);
    }
    f0 = quad_1d( 1, &a0, &df0, NULL);
    f1 = quad_1d( 1, &a1, &df1, NULL);
    a = interpolate_qls( a0, f0, df0, a1, f1, df1);
    if( fabs( a) > quad_tol ){
      status += 1;
    }
  }
  /* Test the guassian:*/

  if( status == 0 ){
    fprintf( stdout, "pass\n" );
  }else{
    fprintf( stdout, "fail\n" );
  }
}
コード例 #2
0
ファイル: init.c プロジェクト: MIkioBo/para_2d-stencil
void init_rand(double **primary, double **vectors){
  debug("init\n");
  srand((unsigned int)time((time_t*) NULL));

  for (int i = 0; i < options.n; i++){
    primary[i] = malloc(options.m * sizeof(double));
    if (primary[i] == NULL){
      bail_out(EXIT_FAILURE, "malloc primary[%d]", i);
    }
    for (int j = 0; j < options.m; j++){
      primary[i][j] = rand_double();
    }
  }

  int vec_len = 0;
  for (int i = 0; i < NUM_VEC; i++){
    if (i%2 == 0){
      vec_len = options.m;
    }
    else{
      vec_len = options.n;
    }
    vectors[i] = malloc(vec_len * sizeof(double));
    if (vectors[i] == NULL){
      bail_out(EXIT_FAILURE, "malloc vectors[%d]\n", i);
    }
    for (int j = 0; j < vec_len; j++){
      vectors[i][j] = rand_double();
    }
  }
  debug("in init: %f", vectors[0][0]);
}
コード例 #3
0
ファイル: Jittered.cpp プロジェクト: dunkirk16/rayTracer
void
Jittered::generate_samples(void) {	
	int n = (int) sqrt((double)num_samples); 
	
	for (int p = 0; p < num_sets; p++)
		for (int j = 0; j < n; j++)		
			for (int k = 0; k < n; k++) {
				Point2D sp((k + rand_double()) / n, (j + rand_double()) / n);				
				samples.push_back(sp);
			}		
}
コード例 #4
0
HeadBumpParticle::HeadBumpParticle(Graphics& graphics,
        Vector<units::Game> center_pos) :
    sprite_(graphics, "Caret",
            units::gameToPixel(kSourceX),
            units::gameToPixel(kSourceY),
            units::gameToPixel(kSourceWidth),
            units::gameToPixel(kSourceHeight)),
    live_timer_(kLifeTime, kTimerStartActive),
    center_pos_(std::move(center_pos)),
    particle_a_(0, rand_angle()),
    particle_b_(0, rand_angle()),
    game_max_offset_a_{static_cast<units::Game>(rand_double(4.0, 20.0))},
    game_max_offset_b_{static_cast<units::Game>(rand_double(4.0, 20.0))}
{}
コード例 #5
0
ファイル: babl-gen-test-pixels.c プロジェクト: LebedevRI/babl
static void gen_path_pixels (void)
{
  int i;
  srandom (20050728);

  printf ("static const int babl_num_path_test_pixels = %d;\n\n", BABL_PATH_NUM_TEST_PIXELS);

  printf ("static const double babl_path_test_pixels[%d] = {\n", BABL_PATH_NUM_TEST_PIXELS * 4);

  /*  add 128 pixels in the valid range between 0.0 and 1.0  */
  for (i = 0; i < 256; i++)
    {
      printf ("%a, %a, %a, %a,\n",
        rand_double (),
        rand_double (),
        rand_double (),
        rand_double ());
    }

  /*  add 16 pixels between -1.0 and 0.0  */
  for (i = 0; i < 16; i++)
    {
      printf ("%a, %a, %a, %a,\n",
        rand_range_double (-1.0, 0.0),
        rand_range_double (-1.0, 0.0),
        rand_range_double (-1.0, 0.0),
        rand_range_double (-1.0, 0.0));
    }

  /*  add 16 pixels between 1.0 and 2.0  */
  for (i = 0; i < 16; i++)
    {
      printf ("%a, %a, %a, %a,\n",
        rand_range_double (1.0, 2.0),
        rand_range_double (1.0, 2.0),
        rand_range_double (1.0, 2.0),
        rand_range_double (1.0, 2.0));
    }

  for (i = 288; i < BABL_PATH_NUM_TEST_PIXELS; i++)
    {
      printf ("%a, %a, %a, %a,\n",
        rand_double (),
        rand_double (),
        rand_double (),
        rand_double ());
    }

  printf ("};\n\n");

  printf ("static const int babl_num_conversion_test_pixels = %d;\n\n", BABL_CONVERSION_NUM_TEST_PIXELS);

  printf ("static const double *babl_conversion_test_pixels = babl_path_test_pixels;\n\n");

  printf ("static const int babl_num_format_test_pixels = %d;\n\n", BABL_FROMAT_NUM_TEST_PIXELS);

  printf ("static const double *babl_format_test_pixels = babl_path_test_pixels;\n\n");
}
コード例 #6
0
ファイル: intrinsics-2.c プロジェクト: 0day-ci/gcc
vec_double2 rand_vd(double min, double max)
{
  int i;
  static v128 val;

  for (i=0; i<2; i++) val.d[i] = rand_double(min, max);
  return (val.vd);
}
コード例 #7
0
T* balanced_reduction_input_a(void) {
  T *ptr = new T[BALANCED_REDUCTION_SIZE];

  for (int i=0; i<BALANCED_REDUCTION_SIZE; i++) {
    ptr[i] = (T)rand_double(-1.0, 1.0);
  }

  return ptr;
}
コード例 #8
0
ファイル: lzdatagen.c プロジェクト: jibsen/lzdatagen
/**
 * Generate random literals.
 *
 * Generate literals following a power distribution. If `lit_exp` is 1.0, the
 * distribution is linear. As `lit_exp` grows, the likelihood of small values
 * increases.
 *
 * @param ptr pointer to where to store literals
 * @param size number of literals to generate
 * @param lit_exp exponent used for distribution
 */
static void
generate_literals(unsigned char *ptr, size_t size, double lit_exp)
{
	size_t i;

	for (i = 0; i < size; ++i) {
		ptr[i] = (unsigned char) (256 * pow(rand_double(), lit_exp));
	}
}
コード例 #9
0
ファイル: nbody.cpp プロジェクト: zmeadows/nbody
nbody_solver::nbody_solver(
    const size_t _DIM,
    const size_t _N,
    const real_t _dt_param)
    : DIM(_DIM),
      N(_N+1),
      dt_param(_dt_param),
      mass(new real_t[N]),
      pos(new real_t[N*DIM]),
      vel(new real_t[N*DIM]),
      acc(new real_t[N*_DIM]),
      jerk(new real_t[N*_DIM]),
      old_pos(new real_t[N*_DIM]),
      old_vel(new real_t[N*_DIM]),
      old_acc(new real_t[N*_DIM]),
      old_jerk(new real_t[N*_DIM]),
      time_elapsed(0),
      steps_taken(0)

{
    srand (time(NULL));

    size_t i,k;
    for (i = 0; i < _N; ++i) {
        mass[i] = rand_double(10,1000);
        for (k = 0; k < DIM; ++k) {
            real_t r = rand_double(20,100);
            pos[i*DIM+k] = r;
        }
        real_t theta_v = M_PI/2 - atan(pos[i*DIM]/pos[i*DIM+1]);
        real_t mag_v = 500;
        vel[i*DIM] = signum(pos[i*DIM + 1]) * cos(theta_v) * mag_v;
        vel[i*DIM+1] = - signum(pos[i*DIM + 0]) * sin(theta_v) * mag_v;


    }

    mass[N-1] = 9999000;
    pos[DIM*(N-1)] = 60;
    pos[DIM*(N-1)+1] = 60;
    vel[DIM*(N-1)] = 0;
    vel[DIM*(N-1)+1] = 0;
    advance_step();
}
コード例 #10
0
ファイル: House.cpp プロジェクト: quatrevingtdeux/infinicity
void House::Build()
{
	double max_step = 8.f;
	if (sqrt(Surface(*vertices))/City::HumanSize >= 20.f)
	{
		max_step = 3.f;
	}
	
	CreatePyramid(rand_double(1.f, max_step));
}
コード例 #11
0
ファイル: light.cpp プロジェクト: sbroadhead/lray
Color Light::Sample(Point const& point, Ray *out_ray, int row, int col) const {
  Point sample_point(0.0, 0.0, 0.0);
  double cell_width = 1.0 / cols;
  double cell_height = 1.0 / rows;

  if (area) {
    double offx = rand_double(-0.25, 0.25) / cols;
    double offy = rand_double(-0.25, 0.25) / rows;
    double x = (col * cell_width + offx) - 0.5;
    double y = (row * cell_height + offy) - 0.5;
    sample_point = Point(x, 0.0, y);
  }

  sample_point = transformation.Apply(sample_point);
  if (out_ray) {
    *out_ray = Ray(point, Normalized(sample_point - point));
    (*out_ray).max_dist = Norm(sample_point - point);
  }

  // In future, this may be deferred to a subclass for e.g. multicolored lights
  return color;
}
コード例 #12
0
ファイル: ldbsim.c プロジェクト: mdcallag/mytools
void stats_report_with_latency(operation_stats* stats,
                               long latency,
       		               struct drand48_data* randctx,
			       longlong bytes_read,
			       longlong bytes_written) {
  int sample_index;

  stats->total_requests++;
  stats->total_latency += latency;
  stats->total_bytes_read += bytes_read;
  stats->total_bytes_written += bytes_written;

  stats->interval_requests++;
  stats->interval_latency += latency;
  stats->interval_bytes_read += bytes_read;
  stats->interval_bytes_written += bytes_written;

  if (latency > stats->interval_max)
    stats->interval_max = latency;

  if (latency > stats->total_max)
    stats->total_max = latency;

  /* Use Reservoir sampling */

  if (stats->interval_requests <= INTERVAL_MAX)
    sample_index = stats->interval_requests - 1;
  else
    sample_index = rand_double(randctx) * stats->interval_requests;
  if (sample_index < INTERVAL_MAX)
    stats->interval_latencies[sample_index] = latency; 

  if (stats->total_requests <= TOTAL_MAX)
    sample_index = stats->total_requests - 1;
  else
    sample_index = rand_double(randctx) * stats->total_requests;
  if (sample_index < TOTAL_MAX)
    stats->total_latencies[sample_index] = latency; 
}
コード例 #13
0
void ProduceTree(double measure, opt_binary_region root, unordered_map<vector<string>, opt_binary_region, hasher>& known, unordered_map<vector<string>, double, hasher>& Tree, deque<binary_region >& b_r_Partition,  double OPTerV, bool flag_rand){
		
		pair<int, int> OnePartition;
		double Precise2 = pow(0.5, 30); 

		unordered_map<vector<string>, opt_binary_region, hasher>::iterator itr = known.find(root.code);
		int partdf = itr->second.postpart;
		if( partdf==-1 || (!flag_rand && itr->second.postrou > 0.5) || (flag_rand && rand_double()<itr->second.postrou) ){ 
			double density = measure/itr->second.area();
			Tree[root.code] = density;
			if(root.area() > OPTerV-Precise2) {
				binary_region b_r_region;
				b_r_region.dim = root.dim;
				b_r_region.code =  root.code;
				b_r_region.samples =  root.samples;
				b_r_region.ranges =  root.ranges;
				b_r_Partition.push_back(b_r_region);
				
			}
			return;
		}
		if(root.area() < OPTerV*2.0-Precise2 && root.area() > OPTerV-Precise2 ){
			binary_region b_r_region;
			b_r_region.dim = root.dim;
			b_r_region.code =  root.code;
			b_r_region.samples =  root.samples;
			b_r_region.ranges =  root.ranges;
			b_r_Partition.push_back(b_r_region);
		}


		opt_binary_region son1, son2;
		son1 = root;
		son2 = root;
		double middle = (root.ranges[partdf].first + root.ranges[partdf].second)/2;
		son1.ranges[partdf].second = son2.ranges[partdf].first = middle;
		son1.code[partdf] = son1.code[partdf]+"0";
		son2.code[partdf] = son2.code[partdf]+"1";
		
		PtsInReg2sons(son1,son2, root.samples, son1.samples, son2.samples);

		
		int num1 = (int)son1.samples.data.size();
		int num2 = (int)son2.samples.data.size();

		ProduceTree(measure * (num1+0.5) /(num1+num2+1), son1, known, Tree, b_r_Partition,OPTerV, flag_rand);
		
		ProduceTree(measure * (num2+0.5) /(num1+num2+1), son2,  known, Tree, b_r_Partition, OPTerV, flag_rand);
		return;
}
コード例 #14
0
ファイル: util.c プロジェクト: csail/airblue
Complex gaussian()
{
  double x1, x2, r2;

  do
    {
      /* choose x,y in uniform square (-1,-1) to (+1,+1) */

      x1 = -1 + 2 * rand_double();
      x2 = -1 + 2 * rand_double();

      /* see if it is in the unit circle */
      r2 = x1 * x1 + x2 * x2;
    }
  while (r2 > 1.0 || r2 == 0);

  /* Box-Muller transform */
  double y1 = x1 * sqrt (-2.0 * log (r2) / r2);
  double y2 = x2 * sqrt (-2.0 * log (r2) / r2);

  Complex ret = { y1, y2 };
  return ret;
}
コード例 #15
0
ファイル: 1.c プロジェクト: sajjadrahnama7/ALG-Homework
int main(int argc , char ** args){
	if(argc < 2){
		printf("wrong input\n");
		return 0;
	}
	double input = atof(args[1]);
	if(input > 1){
		printf("enter number p between 0 and 1\n");
		return 0;
	}
	srand(time(NULL));
	int observe = 0;
	for (int i = 0; i < RAND_NUM_1; ++i){
		if(rand_double() < input)	observe++;
	}
	printf("for %d number\t\t : %.2lf\n", RAND_NUM_1,(double)observe/RAND_NUM_1);
	observe=0;

	for (int i = 0; i < RAND_NUM_2; ++i){
		if(rand_double() < input)	observe++;	
	}
	printf("for %d number\t\t : %.2lf\n", RAND_NUM_2,(double)observe/RAND_NUM_2);
	observe=0;
	
	for (int i = 0; i < RAND_NUM_3; ++i){
		if(rand_double() < input)	observe++;
	}
	printf("for %d number\t\t : %.2lf\n", RAND_NUM_3,(double)observe/RAND_NUM_3);
	observe=0;	
	
	for (int i = 0; i < RAND_NUM_4; ++i){
		if(rand_double() < input)	observe++;
	}
	
	printf("for %d number\t : %.2lf\n", RAND_NUM_4,(double)observe/RAND_NUM_4);

}
コード例 #16
0
ファイル: violated_wifi.c プロジェクト: FinalTheory/libdivert
void ip_callback(void *args, void *proc_info_p,
                 struct ip *packet, struct sockaddr *sin) {
    static size_t idx = 0;
    divert_t *handle = args;
    idx++;
    // drop some inbound packets
    if (divert_device_inbound(handle, packet)) {
        if (rand_double() < rate) {
            printf("Dropped packet %zu\n", idx);
            return;
        }
    }
    // re-inject packets into TCP/IP stack
    divert_reinject(handle, packet, -1, sin);
}
コード例 #17
0
ファイル: selection.c プロジェクト: Nesus/ProyectoIA-2015-1
//Select a solution to use mutation or crossover
//using roulette
int select_solution(solution* population, int pop_size){
	int i;
	double offset = 0.0;
	double r = rand_double();
	int pick = 0;
	
	for (i = 0; i < pop_size; i++) {
    	offset += population[i].relative_fitness;
    	if (r < offset) {
        	pick = i;
        	break;
    	}
	}
	return pick;
}
コード例 #18
0
void randomvals_int (t_randomvals *x, t_atom_long value)
{		
	t_rand_gen *gen = &x->gen;
	
	double *means = x->means;
	double *devs = x->devs;
	double *weights = x->weights;
	double *lo_bounds = x->lo_bounds;
	double *hi_bounds = x->hi_bounds;
	
	double randval, mean, dev, lo_bound, hi_bound;
	long i;
	long num_params = x->num_params;
	
	if (value >= 2)
	{
		// Summed windowed gaussians random distribution
		
		// Choose a mean and dev pair based on weighting
		
		randval = rand_double_n(gen, weights[num_params - 1]);
		
		for (i = 0; i < num_params - 1; i++)
			if (randval < weights[i])
				break;
		
		// Generate a windowed gaussian number (between 0 and 1) using a fast implementation
		
		mean = means[i];
		dev = devs[i];
		lo_bound = lo_bounds[i];
		hi_bound = hi_bounds[i];
		
		randval =  ltqnorm(0.5 + 0.5 * rand_double_range(gen, lo_bound, hi_bound)) * dev + mean;
		if (randval > 1.)
			randval = 1.;
		if (randval < 0.)
			randval = 0.;
	}
	else 
	{
		// Generate a flat distribution random number between 0 and 1
		
		randval = rand_double(gen);
	}
	
	outlet_float(x->the_outlet, randval);	
}
コード例 #19
0
ファイル: Life.c プロジェクト: uberj/Summer411Code
/*
 * Initialize a Life grid. Each cell has a [prob] chance
 * of starting alive.
 */
void randomize_grid (struct life_t * life, double prob) 
{
	int i,j;
	int ncols = life->ncols;
	int nrows = life->nrows;
	int tcols = life->tcols;
	int ubound = life->ubound;
	int lbound = life->lbound;

	for (i = 1; i <= nrows; i++) {
		for (j = 1; j <= tcols; j++) {
			if (rand_double() < prob && j <= ubound+1 && j >= lbound+1)
				life->grid[i][j - lbound] = ALIVE;
		}
	}
}
コード例 #20
0
ファイル: lzdatagen.c プロジェクト: jibsen/lzdatagen
/**
 * Generate random lengths.
 *
 * Generate length frequencies following a power distribution. If `len_exp` is
 * 1.0, the distribution is linear. As `len_exp` grows, the likelihood of small
 * values increases.
 *
 * @note The size of the frequency table is `NUM_LEN`, the range of possible
 * length values, while `num` is the number of length values to generate.
 *
 * @param len_freq pointer to where to store length frequencies
 * @param num number of lengths to generate
 * @param len_exp exponent used for distribution
 */
static void
generate_lengths(unsigned int len_freq[NUM_LEN], size_t num, double len_exp)
{
	size_t i;

	for (i = 0; i < NUM_LEN; ++i) {
		len_freq[i] = 0;
	}

	for (i = 0; i < num; ++i) {
		size_t len = (size_t) (NUM_LEN * pow(rand_double(), len_exp));

		assert(len < NUM_LEN);

		len_freq[len]++;
	}
}
コード例 #21
0
ファイル: main.c プロジェクト: kanitaoru/Craft
int main(int argc, char **argv) {
    srand(time(NULL));
    rand();
    if (argc == 2 || argc == 3) {
        char *hostname = argv[1];
        int port = DEFAULT_PORT;
        if (argc == 3) {
            port = atoi(argv[2]);
        }
        db_disable();
        client_enable();
        client_connect(hostname, port);
        client_start();
    }
    if (!glfwInit()) {
        return -1;
    }
    create_window();
    if (!window) {
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSwapInterval(VSYNC);
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
    glfwSetKeyCallback(window, on_key);
    glfwSetMouseButtonCallback(window, on_mouse_button);
    glfwSetScrollCallback(window, on_scroll);

    #ifndef __APPLE__
        if (glewInit() != GLEW_OK) {
            return -1;
        }
    #endif

    if (db_init()) {
        return -1;
    }

    glEnable(GL_CULL_FACE);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LINE_SMOOTH);
    glLogicOp(GL_INVERT);
    glClearColor(0.53, 0.81, 0.92, 1.00);

    GLuint texture;
    glGenTextures(1, &texture);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    load_png_texture("texture.png");

    GLuint block_program = load_program(
        "shaders/block_vertex.glsl", "shaders/block_fragment.glsl");
    GLuint matrix_loc = glGetUniformLocation(block_program, "matrix");
    GLuint camera_loc = glGetUniformLocation(block_program, "camera");
    GLuint sampler_loc = glGetUniformLocation(block_program, "sampler");
    GLuint timer_loc = glGetUniformLocation(block_program, "timer");
    GLuint position_loc = glGetAttribLocation(block_program, "position");
    GLuint normal_loc = glGetAttribLocation(block_program, "normal");
    GLuint uv_loc = glGetAttribLocation(block_program, "uv");

    GLuint line_program = load_program(
        "shaders/line_vertex.glsl", "shaders/line_fragment.glsl");
    GLuint line_matrix_loc = glGetUniformLocation(line_program, "matrix");
    GLuint line_position_loc = glGetAttribLocation(line_program, "position");

    GLuint item_position_buffer = 0;
    GLuint item_normal_buffer = 0;
    GLuint item_uv_buffer = 0;
    int previous_block_type = 0;

    Chunk chunks[MAX_CHUNKS];
    int chunk_count = 0;

    Player players[MAX_PLAYERS];
    int player_count = 0;

    FPS fps = {0, 0};
    float matrix[16];
    float x = (rand_double() - 0.5) * 10000;
    float z = (rand_double() - 0.5) * 10000;
    float y = 0;
    float dy = 0;
    float rx = 0;
    float ry = 0;
    double px = 0;
    double py = 0;

    int loaded = db_load_state(&x, &y, &z, &rx, &ry);
    ensure_chunks(chunks, &chunk_count,
        floorf(roundf(x) / CHUNK_SIZE),
        floorf(roundf(z) / CHUNK_SIZE), 1);
    if (!loaded) {
        y = highest_block(chunks, chunk_count, x, z) + 2;
    }

    glfwGetCursorPos(window, &px, &py);
    double previous = glfwGetTime();
    while (!glfwWindowShouldClose(window)) {
        update_fps(&fps, SHOW_FPS);
        double now = glfwGetTime();
        double dt = MIN(now - previous, 0.2);
        previous = now;

        if (exclusive && (px || py)) {
            double mx, my;
            glfwGetCursorPos(window, &mx, &my);
            float m = 0.0025;
            rx += (mx - px) * m;
            ry -= (my - py) * m;
            if (rx < 0) {
                rx += RADIANS(360);
            }
            if (rx >= RADIANS(360)){
                rx -= RADIANS(360);
            }
            ry = MAX(ry, -RADIANS(90));
            ry = MIN(ry, RADIANS(90));
            px = mx;
            py = my;
        }
        else {
            glfwGetCursorPos(window, &px, &py);
        }

        int sz = 0;
        int sx = 0;
        ortho = glfwGetKey(window, 'F');
        fov = glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) ? 15.0 : 65.0;
        if (glfwGetKey(window, 'Q')) break;
        if (glfwGetKey(window, 'W')) sz--;
        if (glfwGetKey(window, 'S')) sz++;
        if (glfwGetKey(window, 'A')) sx--;
        if (glfwGetKey(window, 'D')) sx++;
        float m = dt * 1.0;
        if (glfwGetKey(window, GLFW_KEY_LEFT)) rx -= m;
        if (glfwGetKey(window, GLFW_KEY_RIGHT)) rx += m;
        if (glfwGetKey(window, GLFW_KEY_UP)) ry += m;
        if (glfwGetKey(window, GLFW_KEY_DOWN)) ry -= m;
        float vx, vy, vz;
        get_motion_vector(flying, sz, sx, rx, ry, &vx, &vy, &vz);
        if (glfwGetKey(window, GLFW_KEY_SPACE)) {
            if (flying) {
                vy = 1;
            }
            else if (dy == 0) {
                dy = 8;
            }
        }
        if (glfwGetKey(window, 'Z')) {
            vx = -1; vy = 0; vz = 0;
        }
        if (glfwGetKey(window, 'X')) {
            vx = 1; vy = 0; vz = 0;
        }
        if (glfwGetKey(window, 'C')) {
            vx = 0; vy = -1; vz = 0;
        }
        if (glfwGetKey(window, 'V')) {
            vx = 0; vy = 1; vz = 0;
        }
        if (glfwGetKey(window, 'B')) {
            vx = 0; vy = 0; vz = -1;
        }
        if (glfwGetKey(window, 'N')) {
            vx = 0; vy = 0; vz = 1;
        }
        float speed = flying ? 20 : 5;
        int step = 8;
        float ut = dt / step;
        vx = vx * ut * speed;
        vy = vy * ut * speed;
        vz = vz * ut * speed;
        for (int i = 0; i < step; i++) {
            if (flying) {
                dy = 0;
            }
            else {
                dy -= ut * 25;
                dy = MAX(dy, -250);
            }
            x += vx;
            y += vy + dy * ut;
            z += vz;
            if (collide(chunks, chunk_count, 2, &x, &y, &z)) {
                dy = 0;
            }
        }
        if (y < 0) {
            y = highest_block(chunks, chunk_count, x, z) + 2;
        }

        for (int i = 0; i < chunk_count; i++) {
            Chunk *chunk = chunks + i;
            chunk->dirty = 0;
        }

        if (left_click) {
            left_click = 0;
            int hx, hy, hz;
            int hw = hit_test(chunks, chunk_count, 0, x, y, z, rx, ry,
                &hx, &hy, &hz);
            if (hy > 0 && is_destructable(hw)) {
                set_block(chunks, chunk_count, hx, hy, hz, 0, 1);
            }
        }

        if (right_click) {
            right_click = 0;
            int hx, hy, hz;
            int hw = hit_test(chunks, chunk_count, 1, x, y, z, rx, ry,
                &hx, &hy, &hz);
            if (is_obstacle(hw)) {
                if (!player_intersects_block(2, x, y, z, hx, hy, hz)) {
                    set_block(chunks, chunk_count, hx, hy, hz, block_type, 1);
                }
            }
        }

        if (middle_click) {
            middle_click = 0;
            int hx, hy, hz;
            int hw = hit_test(chunks, chunk_count, 0, x, y, z, rx, ry,
                &hx, &hy, &hz);
            if (is_selectable(hw)) {
                block_type = hw;
            }
        }

        if (teleport) {
            teleport = 0;
            if (player_count) {
                int index = rand_int(player_count);
                Player *player = players + index;
                x = player->x;
                y = player->y;
                z = player->z;
                rx = player->rx;
                ry = player->ry;
                ensure_chunks(chunks, &chunk_count,
                    floorf(roundf(x) / CHUNK_SIZE),
                    floorf(roundf(z) / CHUNK_SIZE), 1);
            }
        }

        client_position(x, y, z, rx, ry);
        char buffer[RECV_BUFFER_SIZE];
        while (client_recv(buffer, RECV_BUFFER_SIZE)) {
            float ux, uy, uz, urx, ury;
            if (sscanf(buffer, "U,%*d,%f,%f,%f,%f,%f",
                &ux, &uy, &uz, &urx, &ury) == 5)
            {
                x = ux; y = uy; z = uz; rx = urx; ry = ury;
                ensure_chunks(chunks, &chunk_count,
                    floorf(roundf(x) / CHUNK_SIZE),
                    floorf(roundf(z) / CHUNK_SIZE), 1);
                y = highest_block(chunks, chunk_count, x, z) + 2;
            }
            int bx, by, bz, bw;
            if (sscanf(buffer, "B,%*d,%*d,%d,%d,%d,%d",
                &bx, &by, &bz, &bw) == 4)
            {
                set_block(chunks, chunk_count, bx, by, bz, bw, 0);
                if ((int)roundf(x) == bx && (int)roundf(z) == bz) {
                    y = highest_block(chunks, chunk_count, x, z) + 2;
                }
            }
            int pid;
            float px, py, pz, prx, pry;
            if (sscanf(buffer, "P,%d,%f,%f,%f,%f,%f",
                &pid, &px, &py, &pz, &prx, &pry) == 6)
            {
                Player *player = find_player(players, player_count, pid);
                if (!player && player_count < MAX_PLAYERS) {
                    player = players + player_count;
                    player_count++;
                    player->id = pid;
                    player->position_buffer = 0;
                    player->normal_buffer = 0;
                    player->uv_buffer = 0;
                    printf("%d other players are online\n", player_count);
                }
                if (player) {
                    update_player(player, px, py, pz, prx, pry);
                }
            }
            if (sscanf(buffer, "D,%d", &pid) == 1) {
                delete_player(players, &player_count, pid);
                printf("%d other players are online\n", player_count);
            }
        }

        for (int i = 0; i < chunk_count; i++) {
            Chunk *chunk = chunks + i;
            if (chunk->dirty) {
                update_chunk(chunk);
            }
        }

        int p = floorf(roundf(x) / CHUNK_SIZE);
        int q = floorf(roundf(z) / CHUNK_SIZE);
        ensure_chunks(chunks, &chunk_count, p, q, 0);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        update_matrix_3d(matrix, x, y, z, rx, ry);

        // render chunks
        glUseProgram(block_program);
        glUniformMatrix4fv(matrix_loc, 1, GL_FALSE, matrix);
        glUniform3f(camera_loc, x, y, z);
        glUniform1i(sampler_loc, 0);
        glUniform1f(timer_loc, glfwGetTime());
        for (int i = 0; i < chunk_count; i++) {
            Chunk *chunk = chunks + i;
            if (chunk_distance(chunk, p, q) > RENDER_CHUNK_RADIUS) {
                continue;
            }
            if (!chunk_visible(chunk, matrix)) {
                continue;
            }
            draw_chunk(chunk, position_loc, normal_loc, uv_loc);
        }

        // render players
        for (int i = 0; i < player_count; i++) {
            Player *player = players + i;
            draw_player(player, position_loc, normal_loc, uv_loc);
        }

        // render focused block wireframe
        int hx, hy, hz;
        int hw = hit_test(
            chunks, chunk_count, 0, x, y, z, rx, ry, &hx, &hy, &hz);
        if (is_obstacle(hw)) {
            glUseProgram(line_program);
            glLineWidth(1);
            glEnable(GL_COLOR_LOGIC_OP);
            glUniformMatrix4fv(line_matrix_loc, 1, GL_FALSE, matrix);
            GLuint cube_buffer = make_cube_buffer(hx, hy, hz, 0.51);
            draw_lines(cube_buffer, line_position_loc, 3, 48);
            glDeleteBuffers(1, &cube_buffer);
            glDisable(GL_COLOR_LOGIC_OP);
        }

        update_matrix_2d(matrix);

        // render crosshairs
        glUseProgram(line_program);
        glLineWidth(4);
        glEnable(GL_COLOR_LOGIC_OP);
        glUniformMatrix4fv(line_matrix_loc, 1, GL_FALSE, matrix);
        GLuint line_buffer = make_line_buffer();
        draw_lines(line_buffer, line_position_loc, 2, 4);
        glDeleteBuffers(1, &line_buffer);
        glDisable(GL_COLOR_LOGIC_OP);

        // render selected item
        update_matrix_item(matrix);
        if (block_type != previous_block_type) {
            previous_block_type = block_type;
            make_single_cube(
                &item_position_buffer, &item_normal_buffer, &item_uv_buffer,
                0, 0, 0, 0.5, block_type);
        }
        glUseProgram(block_program);
        glUniformMatrix4fv(matrix_loc, 1, GL_FALSE, matrix);
        glUniform3f(camera_loc, 0, 0, 5);
        glUniform1i(sampler_loc, 0);
        glUniform1f(timer_loc, glfwGetTime());
        glDisable(GL_DEPTH_TEST);
        draw_single_cube(
            item_position_buffer, item_normal_buffer, item_uv_buffer,
            position_loc, normal_loc, uv_loc);
        glEnable(GL_DEPTH_TEST);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    client_stop();
    db_save_state(x, y, z, rx, ry);
    db_close();
    glfwTerminate();
    return 0;
}
コード例 #22
0
T gaussian_allvars_input_c(void) {
  return (T)rand_double(1.0, 3.0);
}
コード例 #23
0
T gaussian_allvars_input_b(void) {
  return (T)rand_double(-1.0, 1.0);
}
コード例 #24
0
ファイル: rand.c プロジェクト: bobbens/ArtTreeKS
/**
 * @brief Gets a random double following the exponential function for a given lambda.
 */
double rand_double_exponential( double lambda )
{
   return (-1./lambda) * log(rand_double());
}
コード例 #25
0
ファイル: rand.c プロジェクト: bobbens/ArtTreeKS
/**
 * @brief Gets a random boolean.
 */
int rand_bool (void)
{
   return (rand_double() > 0.5);
}
コード例 #26
0
ファイル: main.c プロジェクト: jukajunior/Craft
int main(int argc, char **argv) {
    srand(time(NULL));
    rand();
    if (!glfwInit()) {
        return -1;
    }
    create_window();
    if (!window) {
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSwapInterval(VSYNC);
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
    glfwSetKeyCallback(window, on_key);
    glfwSetMouseButtonCallback(window, on_mouse_button);

    #ifndef __APPLE__
        if (glewInit() != GLEW_OK) {
            return -1;
        }
    #endif

    if (db_init()) {
        return -1;
    }

    glEnable(GL_CULL_FACE);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LINE_SMOOTH);
    glLogicOp(GL_INVERT);
    glClearColor(0.53, 0.81, 0.92, 1.00);

    GLuint vertex_array;
    glGenVertexArrays(1, &vertex_array);
    glBindVertexArray(vertex_array);

    GLuint texture;
    glGenTextures(1, &texture);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    load_png_texture("texture.png");

    GLuint block_program = load_program(
        "shaders/block_vertex.glsl", "shaders/block_fragment.glsl");
    GLuint matrix_loc = glGetUniformLocation(block_program, "matrix");
    GLuint camera_loc = glGetUniformLocation(block_program, "camera");
    GLuint sampler_loc = glGetUniformLocation(block_program, "sampler");
    GLuint timer_loc = glGetUniformLocation(block_program, "timer");
    GLuint position_loc = glGetAttribLocation(block_program, "position");
    GLuint normal_loc = glGetAttribLocation(block_program, "normal");
    GLuint uv_loc = glGetAttribLocation(block_program, "uv");

    GLuint line_program = load_program(
        "shaders/line_vertex.glsl", "shaders/line_fragment.glsl");
    GLuint line_matrix_loc = glGetUniformLocation(line_program, "matrix");
    GLuint line_position_loc = glGetAttribLocation(line_program, "position");

    GLuint item_position_buffer = 0;
    GLuint item_normal_buffer = 0;
    GLuint item_uv_buffer = 0;
    int previous_block_type = 0;

    Chunk chunks[MAX_CHUNKS];
    int chunk_count = 0;

    FPS fps = {0, 0};
    float matrix[16];
    float x = (rand_double() - 0.5) * 10000;
    float z = (rand_double() - 0.5) * 10000;
    float y = 0;
    float dy = 0;
    float rx = 0;
    float ry = 0;
    double px = 0;
    double py = 0;

    int loaded = db_load_state(&x, &y, &z, &rx, &ry);
    ensure_chunks(chunks, &chunk_count,
        floorf(roundf(x) / CHUNK_SIZE),
        floorf(roundf(z) / CHUNK_SIZE), 1);
    if (!loaded) {
        y = highest_block(chunks, chunk_count, x, z) + 2;
    }

    glfwGetCursorPos(window, &px, &py);
    double previous = glfwGetTime();
    while (!glfwWindowShouldClose(window)) {
        update_fps(&fps, SHOW_FPS);
        double now = glfwGetTime();
        double dt = MIN(now - previous, 0.2);
        previous = now;

        if (exclusive && (px || py)) {
            double mx, my;
            glfwGetCursorPos(window, &mx, &my);
            float m = 0.0025;
            rx += (mx - px) * m;
            ry -= (my - py) * m;
            if (rx < 0) {
                rx += RADIANS(360);
            }
            if (rx >= RADIANS(360)){
                rx -= RADIANS(360);
            }
            ry = MAX(ry, -RADIANS(90));
            ry = MIN(ry, RADIANS(90));
            px = mx;
            py = my;
        }
        else {
            glfwGetCursorPos(window, &px, &py);
        }

        if (left_click) {
            left_click = 0;
            int hx, hy, hz;
            int hw = hit_test(chunks, chunk_count, 0, x, y, z, rx, ry,
                &hx, &hy, &hz);
            if (hy > 0 && is_destructable(hw)) {
                set_block(chunks, chunk_count, hx, hy, hz, 0);
            }
        }

        if (right_click) {
            right_click = 0;
            int hx, hy, hz;
            int hw = hit_test(chunks, chunk_count, 1, x, y, z, rx, ry,
                &hx, &hy, &hz);
            if (is_obstacle(hw)) {
                if (!player_intersects_block(2, x, y, z, hx, hy, hz)) {
                    set_block(chunks, chunk_count, hx, hy, hz, block_type);
                }
            }
        }

        int sz = 0;
        int sx = 0;
        ortho = glfwGetKey(window, 'F');
        fov = glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) ? 15.0 : 65.0;
        if (glfwGetKey(window, 'Q')) break;
        if (glfwGetKey(window, 'W')) sz--;
        if (glfwGetKey(window, 'S')) sz++;
        if (glfwGetKey(window, 'A')) sx--;
        if (glfwGetKey(window, 'D')) sx++;
        if (dy == 0 && glfwGetKey(window, GLFW_KEY_SPACE)) {
            dy = 8;
        }
        float vx, vy, vz;
        get_motion_vector(flying, sz, sx, rx, ry, &vx, &vy, &vz);
        if (glfwGetKey(window, 'Z')) {
            vx = -1; vy = 0; vz = 0;
        }
        if (glfwGetKey(window, 'X')) {
            vx = 1; vy = 0; vz = 0;
        }
        if (glfwGetKey(window, 'C')) {
            vx = 0; vy = -1; vz = 0;
        }
        if (glfwGetKey(window, 'V')) {
            vx = 0; vy = 1; vz = 0;
        }
        if (glfwGetKey(window, 'B')) {
            vx = 0; vy = 0; vz = -1;
        }
        if (glfwGetKey(window, 'N')) {
            vx = 0; vy = 0; vz = 1;
        }
        float speed = flying ? 20 : 5;
        int step = 8;
        float ut = dt / step;
        vx = vx * ut * speed;
        vy = vy * ut * speed;
        vz = vz * ut * speed;
        for (int i = 0; i < step; i++) {
            if (flying) {
                dy = 0;
            }
            else {
                dy -= ut * 25;
                dy = MAX(dy, -250);
            }
            x += vx;
            y += vy + dy * ut;
            z += vz;
            if (collide(chunks, chunk_count, 2, &x, &y, &z)) {
                dy = 0;
            }
        }

        int p = floorf(roundf(x) / CHUNK_SIZE);
        int q = floorf(roundf(z) / CHUNK_SIZE);
        ensure_chunks(chunks, &chunk_count, p, q, 0);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        update_matrix_3d(matrix, x, y, z, rx, ry);

        // render chunks
        glUseProgram(block_program);
        glUniformMatrix4fv(matrix_loc, 1, GL_FALSE, matrix);
        glUniform3f(camera_loc, x, y, z);
        glUniform1i(sampler_loc, 0);
        glUniform1f(timer_loc, glfwGetTime());
        for (int i = 0; i < chunk_count; i++) {
            Chunk *chunk = chunks + i;
            if (chunk_distance(chunk, p, q) > RENDER_CHUNK_RADIUS) {
                continue;
            }
            if (!chunk_visible(chunk, matrix)) {
                continue;
            }
            draw_chunk(chunk, position_loc, normal_loc, uv_loc);
        }

        // render focused block wireframe
        int hx, hy, hz;
        int hw = hit_test(chunks, chunk_count, 0, x, y, z, rx, ry, &hx, &hy, &hz);
        if (is_obstacle(hw)) {
            glUseProgram(line_program);
            glLineWidth(1);
            glEnable(GL_COLOR_LOGIC_OP);
            glUniformMatrix4fv(line_matrix_loc, 1, GL_FALSE, matrix);
            GLuint buffer = make_cube_buffer(hx, hy, hz, 0.51);
            draw_lines(buffer, line_position_loc, 3, 48);
            glDeleteBuffers(1, &buffer);
            glDisable(GL_COLOR_LOGIC_OP);
        }

        update_matrix_2d(matrix);

        // render crosshairs
        glUseProgram(line_program);
        glLineWidth(4);
        glEnable(GL_COLOR_LOGIC_OP);
        glUniformMatrix4fv(line_matrix_loc, 1, GL_FALSE, matrix);
        GLuint buffer = make_line_buffer();
        draw_lines(buffer, line_position_loc, 2, 4);
        glDeleteBuffers(1, &buffer);
        glDisable(GL_COLOR_LOGIC_OP);

        // render selected item
        update_matrix_item(matrix);
        if (block_type != previous_block_type) {
            previous_block_type = block_type;
            make_single_cube(
                &item_position_buffer, &item_normal_buffer, &item_uv_buffer,
                block_type);
        }
        glUseProgram(block_program);
        glUniformMatrix4fv(matrix_loc, 1, GL_FALSE, matrix);
        glUniform3f(camera_loc, 0, 0, 5);
        glUniform1i(sampler_loc, 0);
        glUniform1f(timer_loc, glfwGetTime());
        glDisable(GL_DEPTH_TEST);
        draw_single_cube(
            item_position_buffer, item_normal_buffer, item_uv_buffer,
            position_loc, normal_loc, uv_loc);
        glEnable(GL_DEPTH_TEST);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    db_save_state(x, y, z, rx, ry);
    db_close();
    glfwTerminate();
    return 0;
}
コード例 #27
0
ファイル: protocol_client_test.c プロジェクト: m-h-w/samba
static void fill_ctdb_req_control_data(TALLOC_CTX *mem_ctx,
				       struct ctdb_req_control_data *cd,
				       uint32_t opcode)
{
	cd->opcode = opcode;
	switch (opcode) {
	case CTDB_CONTROL_PROCESS_EXISTS:
		cd->data.pid = rand32();
		break;

	case CTDB_CONTROL_STATISTICS:
		break;

	case CTDB_CONTROL_PING:
		break;

	case CTDB_CONTROL_GETDBPATH:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_GETVNNMAP:
		break;

	case CTDB_CONTROL_SETVNNMAP:
		cd->data.vnnmap = talloc(mem_ctx, struct ctdb_vnn_map);
		assert(cd->data.vnnmap != NULL);
		fill_ctdb_vnn_map(mem_ctx, cd->data.vnnmap);
		break;

	case CTDB_CONTROL_GET_DEBUG:
		break;

	case CTDB_CONTROL_SET_DEBUG:
		cd->data.loglevel = rand_int(5);
		break;

	case CTDB_CONTROL_GET_DBMAP:
		break;

	case CTDB_CONTROL_PULL_DB:
		cd->data.pulldb = talloc(mem_ctx, struct ctdb_pulldb);
		assert(cd->data.pulldb != NULL);
		fill_ctdb_pulldb(mem_ctx, cd->data.pulldb);
		break;

	case CTDB_CONTROL_PUSH_DB:
		cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
		assert(cd->data.recbuf != NULL);
		fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
		break;

	case CTDB_CONTROL_GET_RECMODE:
		break;

	case CTDB_CONTROL_SET_RECMODE:
		cd->data.recmode = rand_int(2);
		break;

	case CTDB_CONTROL_STATISTICS_RESET:
		break;

	case CTDB_CONTROL_DB_ATTACH:
		fill_ctdb_string(mem_ctx, &cd->data.db_name);
		assert(cd->data.db_name != NULL);
		break;

	case CTDB_CONTROL_SET_CALL:
		break;

	case CTDB_CONTROL_TRAVERSE_START:
		cd->data.traverse_start = talloc(mem_ctx, struct ctdb_traverse_start);
		assert(cd->data.traverse_start != NULL);
		fill_ctdb_traverse_start(mem_ctx, cd->data.traverse_start);
		break;

	case CTDB_CONTROL_TRAVERSE_ALL:
		cd->data.traverse_all = talloc(mem_ctx, struct ctdb_traverse_all);
		assert(cd->data.traverse_all != NULL);
		fill_ctdb_traverse_all(mem_ctx, cd->data.traverse_all);
		break;

	case CTDB_CONTROL_TRAVERSE_DATA:
		cd->data.rec_data = talloc(mem_ctx, struct ctdb_rec_data);
		assert(cd->data.rec_data != NULL);
		fill_ctdb_rec_data(mem_ctx, cd->data.rec_data);
		break;

	case CTDB_CONTROL_REGISTER_SRVID:
		break;

	case CTDB_CONTROL_DEREGISTER_SRVID:
		break;

	case CTDB_CONTROL_GET_DBNAME:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_ENABLE_SEQNUM:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_UPDATE_SEQNUM:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_DUMP_MEMORY:
		break;

	case CTDB_CONTROL_GET_PID:
		break;

	case CTDB_CONTROL_GET_RECMASTER:
		break;

	case CTDB_CONTROL_SET_RECMASTER:
		cd->data.recmaster = rand_int(32);
		break;

	case CTDB_CONTROL_FREEZE:
		break;

	case CTDB_CONTROL_THAW:
		break;

	case CTDB_CONTROL_GET_PNN:
		break;

	case CTDB_CONTROL_SHUTDOWN:
		break;

	case CTDB_CONTROL_GET_MONMODE:
		break;

	case CTDB_CONTROL_TCP_CLIENT:
		cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
		assert(cd->data.conn != NULL);
		fill_ctdb_connection(mem_ctx, cd->data.conn);
		break;

	case CTDB_CONTROL_TCP_ADD:
		cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
		assert(cd->data.conn != NULL);
		fill_ctdb_connection(mem_ctx, cd->data.conn);
		break;

	case CTDB_CONTROL_TCP_REMOVE:
		cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
		assert(cd->data.conn != NULL);
		fill_ctdb_connection(mem_ctx, cd->data.conn);
		break;

	case CTDB_CONTROL_STARTUP:
		break;

	case CTDB_CONTROL_SET_TUNABLE:
		cd->data.tunable = talloc(mem_ctx, struct ctdb_tunable);
		assert(cd->data.tunable != NULL);
		fill_ctdb_tunable(mem_ctx, cd->data.tunable);
		break;

	case CTDB_CONTROL_GET_TUNABLE:
		fill_ctdb_string(mem_ctx, &cd->data.tun_var);
		assert(cd->data.tun_var != NULL);
		break;

	case CTDB_CONTROL_LIST_TUNABLES:
		break;

	case CTDB_CONTROL_MODIFY_FLAGS:
		cd->data.flag_change = talloc(mem_ctx, struct ctdb_node_flag_change);
		assert(cd->data.flag_change != NULL);
		fill_ctdb_node_flag_change(mem_ctx, cd->data.flag_change);
		break;

	case CTDB_CONTROL_GET_ALL_TUNABLES:
		break;

	case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
		cd->data.addr = talloc(mem_ctx, ctdb_sock_addr);
		assert(cd->data.addr != NULL);
		fill_ctdb_sock_addr(mem_ctx, cd->data.addr);
		break;

	case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
		cd->data.tickles = talloc(mem_ctx, struct ctdb_tickle_list);
		assert(cd->data.tickles != NULL);
		fill_ctdb_tickle_list(mem_ctx, cd->data.tickles);
		break;

	case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
		fill_ctdb_string(mem_ctx, &cd->data.db_name);
		assert(cd->data.db_name != NULL);
		break;

	case CTDB_CONTROL_UPDATE_RECORD:
		cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
		assert(cd->data.recbuf != NULL);
		fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
		break;

	case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
		cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
		assert(cd->data.addr_info != NULL);
		fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
		break;

	case CTDB_CONTROL_TRANSACTION_START:
		cd->data.tid = rand32();
		break;

	case CTDB_CONTROL_TRANSACTION_COMMIT:
		cd->data.tid = rand32();
		break;

	case CTDB_CONTROL_WIPE_DATABASE:
		cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
		assert(cd->data.transdb != NULL);
		fill_ctdb_transdb(mem_ctx, cd->data.transdb);
		break;

	case CTDB_CONTROL_UPTIME:
		break;

	case CTDB_CONTROL_START_RECOVERY:
		break;

	case CTDB_CONTROL_END_RECOVERY:
		break;

	case CTDB_CONTROL_RELOAD_NODES_FILE:
		break;

	case CTDB_CONTROL_TRY_DELETE_RECORDS:
		cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
		assert(cd->data.recbuf != NULL);
		fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
		break;

	case CTDB_CONTROL_ENABLE_MONITOR:
		break;

	case CTDB_CONTROL_DISABLE_MONITOR:
		break;

	case CTDB_CONTROL_ADD_PUBLIC_IP:
		cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
		assert(cd->data.addr_info != NULL);
		fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
		break;

	case CTDB_CONTROL_DEL_PUBLIC_IP:
		cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
		assert(cd->data.addr_info != NULL);
		fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
		break;

	case CTDB_CONTROL_RUN_EVENTSCRIPTS:
		fill_ctdb_string(mem_ctx, &cd->data.event_str);
		assert(cd->data.event_str != NULL);
		break;

	case CTDB_CONTROL_GET_CAPABILITIES:
		break;

	case CTDB_CONTROL_START_PERSISTENT_UPDATE:
		break;

	case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE:
		break;

	case CTDB_CONTROL_RECD_PING:
		break;

	case CTDB_CONTROL_RELEASE_IP:
		cd->data.pubip = talloc(mem_ctx, struct ctdb_public_ip);
		assert(cd->data.pubip != NULL);
		fill_ctdb_public_ip(mem_ctx, cd->data.pubip);
		break;

	case CTDB_CONTROL_TAKEOVER_IP:
		cd->data.pubip = talloc(mem_ctx, struct ctdb_public_ip);
		assert(cd->data.pubip != NULL);
		fill_ctdb_public_ip(mem_ctx, cd->data.pubip);
		break;

	case CTDB_CONTROL_GET_PUBLIC_IPS:
		break;

	case CTDB_CONTROL_GET_NODEMAP:
		break;

	case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
		cd->data.event = rand_int(CTDB_EVENT_MAX);
		break;

	case CTDB_CONTROL_TRAVERSE_KILL:
		cd->data.traverse_start = talloc(mem_ctx, struct ctdb_traverse_start);
		assert(cd->data.traverse_start != NULL);
		fill_ctdb_traverse_start(mem_ctx, cd->data.traverse_start);
		break;

	case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
		cd->data.reclock_latency = rand_double();
		break;

	case CTDB_CONTROL_GET_RECLOCK_FILE:
		break;

	case CTDB_CONTROL_SET_RECLOCK_FILE:
		fill_ctdb_string(mem_ctx, &cd->data.reclock_file);
		assert(cd->data.reclock_file != NULL);
		break;

	case CTDB_CONTROL_STOP_NODE:
		break;

	case CTDB_CONTROL_CONTINUE_NODE:
		break;

	case CTDB_CONTROL_SET_LMASTERROLE:
		cd->data.role = rand_int(2);
		break;

	case CTDB_CONTROL_SET_RECMASTERROLE:
		cd->data.role = rand_int(2);
		break;

	case CTDB_CONTROL_ENABLE_SCRIPT:
		fill_ctdb_string(mem_ctx, &cd->data.script);
		assert(cd->data.script != NULL);
		break;

	case CTDB_CONTROL_DISABLE_SCRIPT:
		fill_ctdb_string(mem_ctx, &cd->data.script);
		assert(cd->data.script != NULL);
		break;

	case CTDB_CONTROL_SET_BAN_STATE:
		cd->data.ban_state = talloc(mem_ctx, struct ctdb_ban_state);
		assert(cd->data.ban_state != NULL);
		fill_ctdb_ban_state(mem_ctx, cd->data.ban_state);
		break;

	case CTDB_CONTROL_GET_BAN_STATE:
		break;

	case CTDB_CONTROL_SET_DB_PRIORITY:
		cd->data.db_prio = talloc(mem_ctx, struct ctdb_db_priority);
		assert(cd->data.db_prio != NULL);
		fill_ctdb_db_priority(mem_ctx, cd->data.db_prio);
		break;

	case CTDB_CONTROL_GET_DB_PRIORITY:
		cd->data.db_prio = talloc(mem_ctx, struct ctdb_db_priority);
		assert(cd->data.db_prio != NULL);
		fill_ctdb_db_priority(mem_ctx, cd->data.db_prio);
		break;

	case CTDB_CONTROL_TRANSACTION_CANCEL:
		break;

	case CTDB_CONTROL_REGISTER_NOTIFY:
		cd->data.notify = talloc(mem_ctx, struct ctdb_notify_data);
		assert(cd->data.notify != NULL);
		fill_ctdb_notify_data(mem_ctx, cd->data.notify);
		break;

	case CTDB_CONTROL_DEREGISTER_NOTIFY:
		cd->data.srvid = rand64();
		break;

	case CTDB_CONTROL_TRANS3_COMMIT:
		cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
		assert(cd->data.recbuf != NULL);
		fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
		break;

	case CTDB_CONTROL_GET_DB_SEQNUM:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_DB_SET_HEALTHY:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_DB_GET_HEALTH:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
		cd->data.addr = talloc(mem_ctx, ctdb_sock_addr);
		assert(cd->data.addr != NULL);
		fill_ctdb_sock_addr(mem_ctx, cd->data.addr);
		break;

	case CTDB_CONTROL_GET_IFACES:
		break;

	case CTDB_CONTROL_SET_IFACE_LINK_STATE:
		cd->data.iface = talloc(mem_ctx, struct ctdb_iface);
		assert(cd->data.iface != NULL);
		fill_ctdb_iface(mem_ctx, cd->data.iface);
		break;

	case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
		cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
		assert(cd->data.conn != NULL);
		fill_ctdb_connection(mem_ctx, cd->data.conn);
		break;

	case CTDB_CONTROL_GET_STAT_HISTORY:
		break;

	case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
		cd->data.key = talloc(mem_ctx, struct ctdb_key_data);
		assert(cd->data.key != NULL);
		fill_ctdb_key_data(mem_ctx, cd->data.key);
		break;

	case CTDB_CONTROL_SET_DB_READONLY:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_CHECK_SRVIDS:
		cd->data.u64_array = talloc(mem_ctx, struct ctdb_uint64_array);
		assert(cd->data.u64_array != NULL);
		fill_ctdb_uint64_array(mem_ctx, cd->data.u64_array);
		break;

	case CTDB_CONTROL_TRAVERSE_START_EXT:
		cd->data.traverse_start_ext = talloc(mem_ctx, struct ctdb_traverse_start_ext);
		assert(cd->data.traverse_start_ext != NULL);
		fill_ctdb_traverse_start_ext(mem_ctx, cd->data.traverse_start_ext);
		break;

	case CTDB_CONTROL_GET_DB_STATISTICS:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_SET_DB_STICKY:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
		break;

	case CTDB_CONTROL_TRAVERSE_ALL_EXT:
		cd->data.traverse_all_ext = talloc(mem_ctx, struct ctdb_traverse_all_ext);
		assert(cd->data.traverse_all_ext != NULL);
		fill_ctdb_traverse_all_ext(mem_ctx, cd->data.traverse_all_ext);
		break;

	case CTDB_CONTROL_RECEIVE_RECORDS:
		cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
		assert(cd->data.recbuf != NULL);
		fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
		break;

	case CTDB_CONTROL_IPREALLOCATED:
		break;

	case CTDB_CONTROL_GET_RUNSTATE:
		break;

	case CTDB_CONTROL_DB_DETACH:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_GET_NODES_FILE:
		break;

	case CTDB_CONTROL_DB_FREEZE:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_DB_THAW:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_DB_TRANSACTION_START:
		cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
		assert(cd->data.transdb != NULL);
		fill_ctdb_transdb(mem_ctx, cd->data.transdb);
		break;

	case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
		cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
		assert(cd->data.transdb != NULL);
		fill_ctdb_transdb(mem_ctx, cd->data.transdb);
		break;

	case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
		cd->data.db_id = rand32();
		break;

	case CTDB_CONTROL_DB_PULL:
		cd->data.pulldb_ext = talloc(mem_ctx, struct ctdb_pulldb_ext);
		assert(cd->data.pulldb_ext != NULL);
		fill_ctdb_pulldb_ext(mem_ctx, cd->data.pulldb_ext);
		break;

	case CTDB_CONTROL_DB_PUSH_START:
		cd->data.pulldb_ext = talloc(mem_ctx, struct ctdb_pulldb_ext);
		assert(cd->data.pulldb_ext != NULL);
		fill_ctdb_pulldb_ext(mem_ctx, cd->data.pulldb_ext);
		break;

	case CTDB_CONTROL_DB_PUSH_CONFIRM:
		cd->data.db_id = rand32();
		break;

	}
}
コード例 #28
0
ファイル: generator.c プロジェクト: ivashov/buddhabrot
void generate_fractal(double cx, double cy, double rwidth, double rheight, Pixmap* out, int iters, long long points)
{
    printf("generate\n");
    const int width = out->width;
    const int height = out->height;
    const double pixelWidth = rwidth / width;
    const double pixelHeight = rheight / height;

#pragma omp parallel
    {
        unsigned* priv_px = calloc(width * height, sizeof(unsigned));
        double* trace = calloc(iters * 2, sizeof(double));
#pragma omp for
        for (long long i = 0; i < points; i++) {
            // 'C' in mandelbrot formula
            const double sx = rand_double();
            const double sy = rand_double();

            double x = 0.0;
            double y = 0.0;

            for (int j = 0; j < iters; j++) {
                // Mandelbrot formulas in R
                const double nx = x * x - y * y + sx;
                const double ny = 2 * x * y + sy;

                x = nx;
                y = ny;

                // Store point in trace
                trace[2 * j] = x;
                trace[2 * j + 1] = y;

                if (x * x + y * y > 6.0) {
                    // Draw trace
                    const int length = j * 2;
                    for (int k = 0; k < length; k += 2) {
                        const int qx = (int) (((trace[k] - cx) + rwidth * 0.5) / pixelWidth);
                        const int qy = (int) (((trace[k + 1] - cy) + rheight * 0.5) / pixelHeight);
                        if (qx >= 0 && qy >= 0 && qx < width && qy < height) {
                            priv_px[width * qy + qx]++;
                        }
                    }
                    break;
                }
            }
        }

#pragma omp critical
        {
            for (int y = 0; y < height; y++) {
                for (int x = 0; x < width; x++) {
                    px_set(out, x, y, px_get(out, x, y) + priv_px[width * y + x]);
                }
            }
        }

        free(trace);
        free(priv_px);
    }
}
コード例 #29
0
ファイル: builtins.c プロジェクト: LiaoPengyu/femtolisp
static value_t fl_randd(value_t *args, u_int32_t nargs)
{
    (void)args; (void)nargs;
    return mk_double(rand_double());
}
コード例 #30
0
ファイル: rand.c プロジェクト: bobbens/ArtTreeKS
/**
 * @brief Gets a random double in the range [low,high].
 */
double rand_double_range( double low, double high )
{
   return (low + (high-low)*rand_double());
}