コード例 #1
0
void read_data()
{
	/* read from external file to internal table */
    table_read("mydata","./workspace/eg03_mixednormal_fakedata.txt",1);

	PAUSE
	return;
}
コード例 #2
0
ファイル: mymodel.cpp プロジェクト: strategist922/Filzbach
void read_data()
{
	/* read in a 1-column table from an external file, into an internal table called mydata */
	/* change the second parameter when reading real data instead of fake data */
	// TODO: change the third parameter to the actual number of columns!
	table_read("mydata", "./workspace/mymodel_fakedata.txt", 0);

	/* add columns for the likelihood function to write predictions */ 
	// table_addcolumn("mydata", <column_name>);
	// ...

	PAUSE // examine printout to visually check the proper data was read
	return;
}
コード例 #3
0
ファイル: egz2_seedrain.cpp プロジェクト: vassilyl/Filzbach
void read_data()
{
    /* read table from external file into internal file called 'mydata' */
    table_read("mydata","./workspace/EgDataz2_seedrain.txt",4);
    numdata = table_numrows("mydata");

    /* in this case, we are going to write into our internal table, the model predictions */
    /* so we need an extra columnd for that */
    table_addcolumn("mydata","predlambda"); /* model predicted average seedling count */
    table_addcolumn("mydata","simulatedcount"); /* model output: random draw for seedling count */

    PAUSE

    return;

}
コード例 #4
0
ファイル: ld-cache.c プロジェクト: Distrotech/binutils
cache_entry *
load_cache_table (char *file_name)
{
  cache_entry *cache = NULL;
  cache_entry **last = &cache;
  table *file = table_open (file_name);
  table_entry *entry;
  while ((entry = table_read (file)) != NULL)
    {
      cache_entry *new_rule = ZALLOC (cache_entry);
      new_rule->line = entry->line;
      new_rule->entry_type = name2i (entry->field[ca_type], cache_type_map);
      new_rule->name = entry->field[ca_derived_name];
      filter_parse (&new_rule->original_fields, entry->field[ca_field_name]);
      new_rule->type = entry->field[ca_type_def];
      /* expression is the concatenation of the remaining fields */
      if (entry->nr_fields > ca_expression)
	{
	  int len = 0;
	  int chi;
	  for (chi = ca_expression; chi < entry->nr_fields; chi++)
	    {
	      len += strlen (" : ") + strlen (entry->field[chi]);
	    }
	  new_rule->expression = NZALLOC (char, len);
	  strcpy (new_rule->expression, entry->field[ca_expression]);
	  for (chi = ca_expression + 1; chi < entry->nr_fields; chi++)
	    {
	      strcat (new_rule->expression, " : ");
	      strcat (new_rule->expression, entry->field[chi]);
	    }
	}
      /* insert it */
      *last = new_rule;
      last = &new_rule->next;
    }
コード例 #5
0
ファイル: fits.c プロジェクト: eddyem/fits_filter
/**
 * read FITS file and fill 'IMAGE' structure (with headers and tables)
 * can't work with image stack - opens the first image met
 * works only with binary tables
 */
IMAGE* readFITS(char *filename, IMAGE **fits){
	FNAME();
	#define TRYRET(f, ...) do{TRYFITS(f, __VA_ARGS__); if(fitsstatus) goto returning;}while(0)
	fitsfile *fp;
	int i, j, hdunum = 0, hdutype, nkeys, keypos;
	int naxis;
	long naxes[2];
	char card[FLEN_CARD];
	IMAGE *img = MALLOC(IMAGE, 1);
	TRYRET(fits_open_file, &fp, filename, READONLY);
	FITSFUN(fits_get_num_hdus, fp, &hdunum);
	if(hdunum < 1){
		WARNX(_("Can't read HDU"));
		fitsstatus = 1;
		goto returning;
	}
	// get image dimensions
	TRYRET(fits_get_img_param, fp, 2, &img->dtype, &naxis, naxes);
	if(naxis > 2){
		WARNX(_("Images with > 2 dimensions are not supported"));
		fitsstatus = 1;
		goto returning;
	}
	img->width = naxes[0];
	img->height = naxes[1];
	DBG("got image %ldx%ld pix, bitpix=%d", naxes[0], naxes[1], img->dtype);
	// loop through all HDUs
	KeyList *list = img->keylist;
	int imghdu = -1;
	for(i = 1; !(fits_movabs_hdu(fp, i, &hdutype, &fitsstatus)); ++i){
		int hdutype;
		TRYFITS(fits_get_hdu_type, fp, &hdutype);
		// types: IMAGE_HDU , ASCII_TBL, BINARY_TBL
		if(fitsstatus) continue;
		DBG("HDU type %d", hdutype);
		//if(hdutype == ASCII_TBL || hdutype == BINARY_TBL){
		if(hdutype == BINARY_TBL){
			table_read(img, fp);
			continue;
		}
		if(imghdu < 1) imghdu = i;
		TRYFITS(fits_get_hdrpos, fp, &nkeys, &keypos);
		if(fitsstatus) continue;
		//DBG("HDU # %d of %d keys", i, nkeys);
		for(j = 1; j <= nkeys; ++j){
			FITSFUN(fits_read_record, fp, j, card);
			if(!fitsstatus){
				if(!list_add_record(&list, card)){
					/// "Не могу добавить запись в список"
					WARNX(_("Can't add record to list"));
				}
				//DBG("key %d: %s", j, card);
			}
		}
	}
	img->keylist = list;
	if(fitsstatus == END_OF_FILE){
		fitsstatus = 0;
	}else{
		fits_report_error(stderr, fitsstatus);
		goto returning;
	}
	if(fits_movabs_hdu(fp, imghdu, &hdutype, &fitsstatus)){
		WARNX(_("Can't open image HDU #%d"), imghdu);
		fitsstatus = 1;
		goto returning;
	}
	size_t sz = naxes[0] * naxes[1];
	img->data = MALLOC(double, sz);
	int stat = 0;
	TRYFITS(fits_read_img, fp, TDOUBLE, 1, sz, NULL, img->data, &stat);
	if(stat) WARNX(_("Found %d pixels with undefined value"), stat);
	DBG("ready");
	#undef TRYRET
returning:
	if(fitsstatus){
		imfree(&img);
	}
	FITSFUN(fits_close_file, fp);
	if(fits){
		FREE(*fits);
		*fits = img;
	}
	return img;
}
コード例 #6
0
ファイル: table_t.c プロジェクト: 1Programmer/splayer
/*
 * perform some basic tests
 */
static	void	io_test(table_t *tab_p)
{
  int		ret, bucket_n, entry_n;
  table_t	*tab2_p;
  
  (void)printf("Performing I/O tests:\n");
  (void)fflush(stdout);
  
#if 0
  {
    long	key, data;
    (void)table_clear(tab_p);
    key = 1;
    data = 2;
    (void)table_insert(tab_p, &key, sizeof(key), &data, sizeof(data), NULL, 0);
    key = 3;
    data = 4;
    (void)table_insert(tab_p, &key, sizeof(key), &data, sizeof(data), NULL, 0);
    key = 5;
    data = 6;
    (void)table_insert(tab_p, &key, sizeof(key), &data, sizeof(data), NULL, 0);
    (void)table_adjust(tab_p, 0);
    dump_table(tab_p);
  }
#endif
  
  ret = table_info(tab_p, &bucket_n, &entry_n);
  if (ret != TABLE_ERROR_NONE) {
    (void)fprintf(stderr, "could not get info of table: %s\n",
		  table_strerror(ret));
    exit(1);
  }
  (void)printf("Table we are writing has %d buckets and %d entries\n",
	       bucket_n, entry_n);
  
  /*
   * dump the table to disk
   */
  int pmode = 0640;
#ifdef win32
  pmode = _S_IREAD | _S_IWRITE;
#endif
  (void)unlink(TABLE_FILE);
  ret = table_write(tab_p, TABLE_FILE, pmode);
  if (ret != TABLE_ERROR_NONE) {
    (void)fprintf(stderr, "could not write table to '%s': %s\n",
		  TABLE_FILE, table_strerror(ret));
    exit(1);
  }
  
#if 0
  dump_table(tab_p);
#endif
  
  /*
   * now read back in the table
   */
  tab2_p = table_read(TABLE_FILE, &ret);
  if (tab2_p == NULL) {
    (void)fprintf(stderr, "could not read in file '%s': %s\n",
		  TABLE_FILE, table_strerror(ret));
    exit(1);
  }
  
  (void)printf("Testing table-read...\n");
  if (test_eq(tab_p, tab2_p, 0)) {
    (void)printf("  equal.\n");
  }
  else {
    (void)printf("  NOT equal.\n");
  }
  
  ret = table_free(tab2_p);
  if (ret != TABLE_ERROR_NONE) {
    (void)fprintf(stderr, "could not free read table: %s\n",
		  table_strerror(ret));
    exit(1);
  }
  
  /*
   * mmap in the table
   */
  tab2_p = table_mmap(TABLE_FILE, &ret);
  if (tab2_p == NULL) {
    (void)fprintf(stderr, "could not mmap file '%s': %s\n",
		  TABLE_FILE, table_strerror(ret));
    exit(1);
  }
  
  (void)printf("Testing table-mmap...\n");
  if (test_eq(tab2_p, tab_p, 0)) {
    (void)printf("  equal.\n");
  }
  else {
    (void)printf("  NOT equal.\n");
  }
  
  ret = table_munmap(tab2_p);
  if (ret != TABLE_ERROR_NONE) {
    (void)fprintf(stderr, "could not munmap file '%s': %s\n",
		  TABLE_FILE, table_strerror(ret));
    exit(1);
  }
}