Ejemplo n.º 1
0
int main (void){
  int i, j, k = 0; 
  gsl_matrix *m = gsl_matrix_alloc (10, 10);
  gsl_matrix *a = gsl_matrix_alloc (10, 10);
  
  for (i = 0; i < 10; i++){
    for (j = 0; j < 10; j++){
      gsl_matrix_set (m, i, j, i*10+j);
		}
	}

     FILE *f = fopen ("test.dat", "w");
     gsl_matrix_fwrite (f, m);
     fclose (f);

     FILE *F = fopen ("test.dat", "r");
     gsl_matrix_fread (F, a);
     fclose (F);

  for (i = 0; i < 10; i++)
    for (j = 0; j < 10; j++){
        double mij = gsl_matrix_get (m, i, j);
        double aij = gsl_matrix_get (a, i, j);
        if (mij != aij) k++;
		}

  gsl_matrix_free (m);
  gsl_matrix_free (a);

  printf ("differences = %d (should be zero)\n", k);
  return (k > 0);
}
Ejemplo n.º 2
0
Archivo: io.c Proyecto: pa345/lib
gsl_matrix *
pca_read_matrix(const char *filename)
{
    FILE *fp;
    gsl_matrix *m;
    size_t size1, size2;

    fp = fopen(filename, "r");
    if (!fp)
    {
        fprintf(stderr, "pca_read_matrix: unable to open %s: %s\n",
                filename, strerror(errno));
        return NULL;
    }

    fread(&size1, sizeof(size_t), 1, fp);
    fread(&size2, sizeof(size_t), 1, fp);

    m = gsl_matrix_alloc(size1, size2);

    gsl_matrix_fread(fp, m);

    fclose(fp);

    return m;
}
Ejemplo n.º 3
0
int
main (void)
{
  int i, j, k = 0; 
  gsl_matrix * m = gsl_matrix_alloc (100, 100);
  gsl_matrix * a = gsl_matrix_alloc (100, 100);
  
  for (i = 0; i < 100; i++)
    for (j = 0; j < 100; j++)
      gsl_matrix_set (m, i, j, 0.23 + i + j);

  {  
     FILE * f = fopen ("test.dat", "wb");
     gsl_matrix_fwrite (f, m);
     fclose (f);
  }

  {  
     FILE * f = fopen ("test.dat", "rb");
     gsl_matrix_fread (f, a);
     fclose (f);
  }

  for (i = 0; i < 100; i++)
    for (j = 0; j < 100; j++)
      {
        double mij = gsl_matrix_get (m, i, j);
        double aij = gsl_matrix_get (a, i, j);
        if (mij != aij) k++;
      }

  printf ("differences = %d (should be zero)\n", k);
  return (k > 0);
}
Ejemplo n.º 4
0
//Reads coupling matrix from file and computes its LU decomposition
void read_coupling_matrix(char *fname_in,int nbins_in,
			  gsl_matrix **coupling_matrix_b_out,
			  gsl_permutation **perm_out,
			  int pol1,int pol2)
{
  int sig,n_cl,stat;
  FILE *fi;
  gsl_permutation *perm;
  gsl_matrix *coupling_matrix_b;

  if(pol1) {
    if(pol2) n_cl=4;
    else n_cl=2;
  }
  else {
    if(pol2) n_cl=2;
    else n_cl=1;
  }
  perm=gsl_permutation_alloc(n_cl*nbins_in);
  coupling_matrix_b=gsl_matrix_alloc(n_cl*nbins_in,n_cl*nbins_in);

  fi=my_fopen(fname_in,"rb");
  stat=gsl_matrix_fread(fi,coupling_matrix_b);
  if(stat==GSL_EFAILED)
    report_error(1,"Error reading matrix from file %s\n",fname_in);
  fclose(fi);

  gsl_linalg_LU_decomp(coupling_matrix_b,perm,&sig);
  *coupling_matrix_b_out=coupling_matrix_b;
  *perm_out=perm;
}
Ejemplo n.º 5
0
void chapeau_loadstate ( chapeau * ch, char * filename ) {
    int i,m,N;
    chapeau * chaux = (chapeau*)malloc(sizeof(chapeau));
    FILE * ofs;
   
    ofs=fopen(filename,"r");

    if (!ch) {
      fprintf(stderr,"CFACV) ERROR in load chapeau file because holding object was not allocated\n");
      exit(-1);
    }

    fread(&i,sizeof(int),1,ofs);
    fprintf(stdout,"CFACV) Recovering chapeau state of step %i of some previous simulation\n",i);

    // With chaux we prevent override of addresses (hits, mask, etc) when
    // reading integers (N,M,et), that is only what we want... better way to do
    // this?
    fread(chaux, sizeof(*chaux), 1, ofs);
    ch->N           = chaux->N          ;
    ch->m           = chaux->m          ;
    ch->nsample     = chaux->nsample    ;
    ch->nupdate     = chaux->nupdate    ;
    ch->alpha       = chaux->alpha      ;
    strcpy(ch->filename,chaux->filename);
    ch->outputFreq  = chaux->outputFreq ;
    ch->outputLevel = chaux->outputLevel;
    ch->rmin        = chaux->rmin       ;
    ch->rmax        = chaux->rmax       ;
    ch->dr          = chaux->dr         ;
    ch->idr         = chaux->idr        ;

    N=ch->N;
    m=ch->m;
     
    fread(ch->hits,sizeof(*(ch->hits)),ch->m,ofs);
    fread(ch->mask,sizeof(*(ch->mask)),ch->N,ofs);

    gsl_matrix_fread(ofs,ch->A);
    gsl_vector_fread(ofs,ch->b);
    gsl_matrix_fread(ofs,ch->Afull);
    gsl_vector_fread(ofs,ch->bfull);
    gsl_vector_fread(ofs,ch->lam);

    fclose(ofs);
    free(chaux);
}
Ejemplo n.º 6
0
static int read_matrix(const char dir[], const char fname[], gsl_matrix *m) {
  size_t size = strlen(dir) + strlen(fname) + 2;
  char *path = XLALMalloc(size);
  snprintf(path, size, "%s/%s", dir, fname);

  FILE *f = fopen(path, "rb");
  if (!f)
    XLAL_ERROR(XLAL_EIO, "Could not find ROM data file at path `%s'", path);
  int ret = gsl_matrix_fread(f, m);
  if (ret != 0)
     XLAL_ERROR(XLAL_EIO, "Error reading data from `%s'", path);
  fclose(f);

  XLAL_PRINT_INFO("Sucessfully read data file `%s'", path);
  XLALFree(path);
  return(XLAL_SUCCESS);
}
Ejemplo n.º 7
0
Archivo: lls.c Proyecto: pa345/lib
int
lls_load(const char *filename, lls_workspace *w)
{
  int s = 0;
  FILE *fp;

  fp = fopen(filename, "r");
  if (!fp)
    {
      fprintf(stderr, "lls_load: unable to open %s: %s\n",
              filename, strerror(errno));
      return GSL_FAILURE;
    }

  fread(&(w->bTb), sizeof(double), 1, fp);
  s += gsl_matrix_fread(fp, w->ATA);
  s += gsl_vector_fread(fp, w->ATb);

  fclose(fp);

  return s;
} /* lls_load() */
Ejemplo n.º 8
0
void crypt_vector(int *a, int n, int factor, int seed) {

	/*
	Opening the coresponding files as streams
	*/

	int i = 0;
	FILE *fp_s;
	FILE *fp_m1;
	FILE *fp_m2;
	if(factor == 0) {
		fp_s = fopen("s.key", "r");
		fp_m1 = fopen("m1_t.key", "r");
		fp_m2 = fopen("m2_t.key", "r");
	}
	else {
		fp_s = fopen("s_i.key", "r");
		fp_m1 = fopen("m1_i.key", "r");
		fp_m2 = fopen("m2_i.key", "r");
	}
	/*
	Allocating memories for the datastructures
	*/
	gsl_vector *org_vector = gsl_vector_alloc(n);
	gsl_vector *s = gsl_vector_alloc(n);
	gsl_matrix *m1 = gsl_matrix_alloc(n,n);
	gsl_matrix *m2 = gsl_matrix_alloc(n,n);


	/* 
	Getting them into memory
	*/
	gsl_vector_fread(fp_s, s);
	gsl_matrix_fread(fp_m1, m1);
	gsl_matrix_fread(fp_m2, m2);



	for(i = 0; i<n; i++)
		gsl_vector_set(org_vector, i, a[i]);

	init_rng(seed);
	
	if(factor == 1) {
		int scale = gsl_rng_uniform_int(r, 100);
		gsl_vector_scale(org_vector, scale);
	}
	
	gsl_vector *splt_vec_1 = gsl_vector_alloc(n);
	gsl_vector *splt_vec_2 = gsl_vector_alloc(n);
    
	split(org_vector, splt_vec_1, splt_vec_2, s, n);
	
	
	/*{
        int j = 0;
        for(j = 0; j<n; j++)
            printf("%d",  (int) gsl_vector_get(org_vector, j));
	    
	    printf("\n\n\n");
        //int i = 0, j = 0;
        for(j = 0; j<n; j++)
            printf("%d",  (int) gsl_vector_get(splt_vec_1, j));
            
        printf("\n\n\n");
        for(j = 0; j<n; j++)
            printf("%d", (int) gsl_vector_get(splt_vec_2, j));
        printf("\n\n");
	}*/
	

	gsl_vector *crp_vector_1 = gsl_vector_alloc(n);
	gsl_vector *crp_vector_2 = gsl_vector_alloc(n);

	compute_crp_vector(splt_vec_1, m1, crp_vector_1, n);
	compute_crp_vector(splt_vec_2, m2, crp_vector_2, n);
	FILE *f_crpt_1 = fopen("crypt_1.key", "w");
	FILE *f_crpt_2 = fopen("crypt_2.key", "w");

	gsl_vector_fwrite(f_crpt_1, crp_vector_1);
	gsl_vector_fwrite(f_crpt_2, crp_vector_2);

	gsl_vector_free(org_vector);
	gsl_vector_free(s);
	gsl_vector_free(splt_vec_1);
	gsl_vector_free(splt_vec_2);
	gsl_vector_free(crp_vector_1);
	gsl_vector_free(crp_vector_2);
	gsl_matrix_free(m1);
	gsl_matrix_free(m2);
	gsl_rng_free(r);

	fclose(fp_s);
	fclose(fp_m1);
	fclose(fp_m2);
	fclose(f_crpt_1);
	fclose(f_crpt_2);

}