Exemple #1
0
int		create_eye(t_all *all, t_list *list, FILE *fd, int *err)
{
  char		*str;
  int		i;

  list = NULL;
  i = 0;
  while ((str = get_next_line_custom(fd)) != NULL && ++ i > 0 &&
	 lexer(&list, str) != -1 && the_end(list, "EYE") == -1)
    {
      if ((strcmp("pos", (list = list->next)->lexeme) == 0 &&
	   init_coords(list->next, &all->eye.pos) == -1) ||
	  (strcmp("rot", list->lexeme) == 0 &&
	   init_coords(list->next, &all->eye.rot) == -1) ||
	  (strcmp("rot", list->lexeme) != 0 &&
	   strcmp("pos", list->lexeme) != 0))
	*err = -1;
      free_things(list, str);
      if (*err == -1)
	return (-1);
      list = NULL;
    }
  if (the_end(list, "EYE") == 0)
    return (i);
  *err = -1;
  return (i);
}
Exemple #2
0
static void * init_drive(lemuria_engine_t * e)
  {
  drive_data * d;
  int random_number;
  d = calloc(1, sizeof(*d));
  init_coords(d);

  d->delta_phi_start = 0.0;
  d->delta_phi_end   = 0.0;

  lemuria_range_init(e, &(d->curvature_range),
                     1, 10, 10);

  random_number = lemuria_random_int(e, 0, 1);

  //  random_number = 1;
  
  switch(random_number)
    {
    case 0:
      lemuria_background_init(e,
                              &(d->drive_background),
                              &(bg_drive_1));
      break;
    case 1:
      lemuria_background_init(e,
                              &(d->drive_background),
                              &(bg_drive_2));
      break;
    }
  

  if(e->goom)
    random_number = lemuria_random_int(e, 0, 1);
  else
    random_number = 1;
  
  //  random_number = 1;
  
  switch(random_number)
    {
    case 0:
      lemuria_background_init(e,
                              &(d->sky_background),
                              &(sky_goom));
      break;
    case 1:
      lemuria_background_init(e,
                              &(d->sky_background),
                              &(sky_lemuria));
      break;
    }
  
  d->speed_start = 0.0;
  d->speed_end = SPEED_MIN + (e->loudness / 32768.0)*(SPEED_MAX - SPEED_MIN);
  lemuria_range_init(e, &(d->speed_range),
                     1, 50, 60);
  
  return d;
  }
Exemple #3
0
void change_set(infoptr pic, point julia_pos) /* julia_pos=hiiren klikkauspiste */
{
  if(pic->is_mandel)  /* Mandelbrot -> Julia */
  {
    pic->is_mandel = FALSE;
    pic->julia_c = to_dpoint(julia_pos, pic);
    init_coords(pic);
    repaint(pic, pic->area);
  }
  else                /* Julia -> Mandelbrot */
  {
    pic->is_mandel = TRUE;
    init_coords(pic);
    repaint(pic, pic->area);
  }
}
Exemple #4
0
void paint_julia_prev(infoptr pic, point mouse_pos)
{
  struct picture_info prev_pic;
  dpoint p, tmp;
  int n = 0;

  prev_pic.area = get_prev_rect(pic);
  init_coords(&prev_pic);    /* Asetetaan sopiva skaalaus */
  /* Julia-vakio hiiren koordinaateista */  
  prev_pic.julia_c = to_dpoint(mouse_pos, pic); 
  SRGP_setClipRectangle(prev_pic.area);
  SRGP_setColor(SRGP_BLACK);  /* Peitetään vanha kuva */
  SRGP_fillRectangleCoord(prev_pic.area.bottom_left.x + 1,
			  prev_pic.area.bottom_left.y + 1,
			  prev_pic.area.top_right.x - 1,
			  prev_pic.area.top_right.y - 1); 
  SRGP_setColor(SRGP_WHITE);  /* Valkea reunus */
  SRGP_rectangle(prev_pic.area);
  p.x = 0;   /* Inverse functionin */
  p.y = 0;   /* alkupiste          */

  while(n < JULIA_LIMIT)
  {   /*  z[n+1] = sqrt(z[n] - c)  */
    tmp.x = p.x - prev_pic.julia_c.x;
    tmp.y = p.y - prev_pic.julia_c.y;
    p = c_sqrt(tmp);
    SRGP_point(to_point(p, &prev_pic));
    n++;
  }
  SRGP_setClipRectangle(pic->area);
}
Exemple #5
0
// initialize player's match information (coords)
void init_player_match(Player_Match* process) {
	int rank;

	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
	process->global_rank = rank;

	// field does not have coordinates
	if (rank == FIELD_0 || rank == FIELD_1) {
		process->initial_coords[0] = INVALID_COORDS ;
		process->initial_coords[1] = INVALID_COORDS ;
		process->final_coords[0] = INVALID_COORDS ;
		process->final_coords[1] = INVALID_COORDS ;
		process->ball_coords[0] = LONG_SIDE/2 ;
		process->ball_coords[1] = SHORT_SIDE/2 ;
		process->reached = INVALID ;
		process->challenge = INVALID ;

	}
	else
	{
		// initial coordinates of players are random
		init_coords(process->initial_coords) ;
		process->final_coords[0] = INVALID_COORDS ;
		process->final_coords[1] = INVALID_COORDS ;
		process->ball_coords[0] = INVALID_COORDS ;
		process->ball_coords[1] = INVALID_COORDS ;
		process->reached = 0 ;
		process->challenge = 0 ;

	}

}
Exemple #6
0
coords* read_newcoo(char *filename) {
    FILE *FP;
    vec boxL = {.x=-1.0, .y=-1.0, .z=-1.0};
    char *buffer = (char*)calloc(MAX_LEN, sizeof(char));
    char *fileformat = (char*)calloc(7, sizeof(char));
    int i=0, nat=0;
    
    printf("\nread_newcoo: filename = %s",filename);
    
    FP=fopen(filename, "rt");
    if (FP == NULL) {
        printf("\n***   read_newcoo:Could not open <%s>.", filename);
        return NULL;
    }
        // read first line of file to get nat, boxL and confirm newcoo-format
    if (fgets(buffer, MAX_LEN, FP) == NULL) {
        printf("\n***   read_newcoo: read from input file failed");
        return NULL;
    }
    sscanf(buffer,"%7s %6d %lf %lf %lf",fileformat, &nat, &boxL.x, &boxL.y, &boxL.z);
    trim(fileformat);
    if (strncmp(fileformat, "new-coo", 7) != 0) {
        printf("\n***   read_newcoo: file format to read is incompatible (not new-coo)");
        return NULL;
    }
    coords *coo = init_coords(nat, boxL);
    printf("\n*** read_newcoo: header = %7s %6d %10.6f %10.4f %10.4f",fileformat, nat, boxL.x, boxL.y, boxL.z);

    for(i=0;i<coo->nat;i++) {
        fgets(buffer, MAX_LEN, FP);
        sscanf(buffer, "%5d %2s %2d %lf %lf %lf\n", &(coo->at[i]->n), coo->at[i]->esymb, &(coo->at[i]->atn), &(coo->at[i]->pnt.x), &(coo->at[i]->pnt.y), &(coo->at[i]->pnt.z));
    }
    fclose(FP);
    return coo;
}
Exemple #7
0
int main(int argc, char *argv[])
{
	int dev, ret_val;
	unsigned int reg_val;

	// find and init FPGA device
	ret_val = fpga_init(argc, argv, &dev);
	if (ret_val<0) return -1;
	
	double dt_c[N];
	double dt_f[N];
	printf("N_d is %d\n",N_d);
	
	printf("N_d is %d\n",N_d);
	
	printf("size is %d\n",(int)SIZE_DWORD);

	try{
		

		x_1.resize(13);
		y_1.resize(13);
		t_1.resize(13);
		x_2.resize(13);
		y_2.resize(13);
		t_2.resize(13);
		for (int i = 0; i < 13; i++){
			x_1[i].resize(N_d);
			y_1[i].resize(N_d);
			t_1[i].resize(N_d);
			x_2[i].resize(N_d);
			y_2[i].resize(N_d);
			t_2[i].resize(N_d);
		}
		
	} catch (const  std::bad_alloc& ba){
		std::cout << "bad_alloc caught: " << ba.what() << std::endl;
	}	
	FILE  *f_p, *f_p1;

	int error = 0;
	if (flag_compare==1){
		f_p = fopen ("MT_coords_CPU.txt","w");
		if (f_p==NULL) {

			printf("Error opening file!\n");
			return -1;
		}
		
	}
	
	if (flag_file)		f_p1 = fopen (out_file,"w");
	else 				f_p1 = fopen ("MT_coords_FPGA.txt","w");
	
	if (f_p1==NULL) {

		printf("Error opening file!\n");
		return -1;
	}
	
	


	printf("TOTAL_STEPS = %d\nSTEPS_TO_WRITE = %d\n", TOTAL_STEPS, STEPS_TO_WRITE);



	// get golden results
	init_coords(x_1,y_1,t_1);
	init_coords(x_2,y_2,t_2);
	



	/*
	* в этом цикле проводим вычислени¤ и сравниваем результаты
	*
	* в данный момент чтобы проверить сравнение на каждом шаге вызываетс¤ функци¤ mt_cpu
	* с параметром load_coords = 1 (иначе состо¤ни¤ глобальных массивов координат будет все врем¤ мен¤тьс¤)
	*
	*  огда вместо mt_cpu будет реализаци¤ на OpenCL, то надо делать по-другому:
	*  перед циклом один раз вызываем mt_cpu (load_coords = 1), в цикле уменьшаем количество итераций на 1 и
	*  вызываем mt_cpu (load_coords = 0)
	*
	*/
	error = 0; 

	
	printf("\nFlag rand is SET, %d\n\n",flag_rand);
	
	if (flag_rand==1) 	  {
		
		srand (time(NULL));
		
		// set seed vals
		for (int i =0; i < NUM_SEEDS; i++){
#ifdef TEST_SEEDS
				seeds[i] = test_seeds[i];
#else
				seeds[i]=rand();
#endif
			unsigned int addr = SEED_REG + 4*i;
			RD_WriteDeviceReg32m(dev, CNTRL_BAR, addr, seeds[i]);	
		}		
		
		printf("\nFlag rand is SET\n\n");
		
		
		RD_ReadDeviceReg32m(dev, CNTRL_BAR, COMMAND_REG, reg_val);
	
		// deassert rand reset
		reg_val |= (1<<4);
		RD_WriteDeviceReg32m(dev, CNTRL_BAR, COMMAND_REG, reg_val);
		
		// set rand_enable flag
		reg_val |= (1<<7);
		RD_WriteDeviceReg32m(dev, CNTRL_BAR, COMMAND_REG, reg_val);

		// start rand core
		reg_val |= (1<<5);	
		RD_WriteDeviceReg32m(dev, CNTRL_BAR, COMMAND_REG, reg_val);		
		

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

	for(int k=0; k<N; k++) {


		int err;
		struct timeval tt1, tt2;
		if (flag_compare==1){
			get_time(&tt1);
			if (mt_cpu(STEPS_TO_WRITE,1, flag_rand, flag_seed, seeds,  x_1,y_1,t_1,x_1,y_1, t_1)<0) { printf("Nan Error in cpu. Step is %d. Exitting....\n",k); break;}

			get_time(&tt2);
			calc_dt(&tt1,&tt2, &dt_c[k]);
		}
		
		get_time(&tt1);
		mt_fpga(dev,STEPS_TO_WRITE,1,x_2,y_2,t_2,x_2,y_2, t_2);
		get_time(&tt2);
		calc_dt(&tt1,&tt2, &dt_f[k]);

		flag_seed = 0; 
		
		printf("Step %d\n\t CPU Time = %f\n\t FPGA Time = %f\n",k,dt_c[k],dt_f[k] );

		if (flag_compare==1){
			err = compare_results(x_1,y_1,t_1,x_2,y_2,t_2);
			if (err) {
				error += err;
				printf("Compare results failed at step = %d, errors = %d\n", k, error);
			}
		}


		if (flag_compare==1)	print_coords(f_p, x_1, y_1, t_1);
		print_coords(f_p1, x_2, y_2, t_2);
		

	}
	if (flag_compare==1){
		if (!error)
		printf("Test OK!\n");
	}
	
	

	if (flag_compare==1) fclose(f_p);
	fclose(f_p1);


	RD_ReadDeviceReg32m(dev, CNTRL_BAR, COMMAND_REG, reg_val);
	
	// assert rand reset
	reg_val &= ~(1<<4);
	RD_WriteDeviceReg32m(dev, CNTRL_BAR, COMMAND_REG, reg_val);
		
	// reset rand_enable flag
	reg_val &= ~(1<<7);
	RD_WriteDeviceReg32m(dev, CNTRL_BAR, COMMAND_REG, reg_val);	
	


	free(wr_buf_free);
	free(rd_buf_free);


	RD_CloseDevice(pd_ptr);
	return 0; 

}