예제 #1
0
파일: nterm.c 프로젝트: rforge/muste
void muste_nterm(int argc, char *argv[])
  {
  int i;
/*
  if (argc==1)
      {
      Rprintf("This program can be used as a SURVO 84C module only.");
      return;
      }
*/      
  s_init(argv[1]);

  i=init_sequence();
  if (i<0) { s_end(argv[1]); return; }
  i=init_regressors();
  if (i<0) return;

  i=linear_regression(seq_n,10);
  if (i<0) return;

  data_close(&data);

  edwrite(nterm_output_buffer,nterm_output_line,1);

  s_end(argv[1]);
}
예제 #2
0
int main(int argc, char *argv[]) {
  printf("Linear Regression\n");
  printf("=================\n\n");

  // Check for a filename
  if (argc == 2) {
    FILE *input = fopen(argv[1], "r");
    
    if (input == NULL) {
      perror(argv[1]);
      exit(1);

    } else {
      DataSet theData = load_data(input);
      fclose(input);
     
      LinRegResult linReg = linear_regression(theData);
      clean(theData);
      printf("\nSlope   \tm = %15.6e\n", DESCALE(linReg.m)); // print slope
      printf("y-intercept\tb = %15.6e\n", DESCALE(linReg.b)); // print y-intercept
      printf("Correlation\tr = %15.6e\n", DESCALE(linReg.r)); // print correlation
    }

  } else {
    printf("ERROR: Must enter filename after ./linReg\n");

  }
  return 0;
}
void test_symplectic_central_force(void** state)
{
    // We use the symplectic Crank-Nicolson method to integrate the trajectory
    // of a particle under the influence of a central force. We test that its
    // energy is conserved, and that the integration error converges to zero
    // at second order accuracy.
    ode_integrator_t* I = symplectic_central_force_integrator();
    real_t rel_tol = 1e-4, abs_tol = 1e-6;
    euler_ode_integrator_set_tolerances(I, rel_tol, abs_tol);
    real_t R = 1.0; // radius of circular orbit.
    real_t V = 1.0; // Linear velocity magnitude.
    real_t T = 2.0 * M_PI * R / V;      // period of rotation

    int num_trials = 4;
    int num_steps_array[4] = {16, 32, 64, 128};
    real_t L2_array[num_trials];
    for (int i = 0; i < num_trials; ++i)
    {
        int num_steps = num_steps_array[i];
        real_t X[4] = {R, 0.0, 0.0, V};     // {x, y, vx, vy}
        real_t dt = T / num_steps;

        // Integrate the trajectory with the given time step.
        real_t t = 0.0;
        for (int j = 0; j < num_steps; ++j)
        {
            bool success = ode_integrator_step(I, dt, &t, X);
//printf("%g %g %g %g %g\n", t, X[0], X[1], X[2], X[3]);
            assert_true(success);
        }

        // Check energy conservation.
        real_t E = 0.5 * (X[2]*X[2] + X[3]*X[3]);
        assert_true(fabs(E - 0.5) < 1e-3);

        // Compute error norms.
        real_t L2 = sqrt((X[0]-R)*(X[0]-R) + X[1]*X[1] + X[2]*X[2] + (X[3]-V)*(X[3]-V));
        L2_array[i] = L2;
    }

    // Compute the convergence rate of the L2 error norm.
    real_t log_n_ratios[num_trials-1], log_L2_ratios[num_trials-1];
    for (int i = 0; i < num_trials-1; ++i)
    {
        log_n_ratios[i] = log(pow(2.0, i));
        log_L2_ratios[i] = log(L2_array[i+1] / L2_array[0]);
    }
    real_t A, B, sigma;
    linear_regression(log_n_ratios, log_L2_ratios, num_trials-1, &A, &B, &sigma);
    real_t L2_conv_rate = -A;
    log_urgent("symplectic central force L2 error conv rate = %g\n", L2_conv_rate);
    assert_true(L2_conv_rate >= 1.9947);

    // Clean up.
    ode_integrator_free(I);
}
예제 #4
0
/*			COMPUTE_SMOOTH_TIME_MAP 
	 compute regression line and estimate point at i
 
	 Number of points in regression is smooth (an odd number). First
	 index to compute is (smooth-1)/2. Use that line for the first
	 (smooth+1)/2 points. The last index to compute is 
	 (file0_frames - (smooth+1)/2). Use that line for the last 
	 (smooth+1)/2 points.
*/
void Scorealign::compute_smooth_time_map()
{
    int i;
    int hw = (smooth - 1) / 2; // half width of smoothing window

    // find the first point
    for (i = 0; i < first_x; i++) {
        smooth_time_map[i] = NOT_MAPPED;
    }

    // do the first points:
    float a, b;
    linear_regression(first_x + hw, smooth, a, b);
    for (i = first_x; i <= first_x + hw; i++) {
        smooth_time_map[i] = a + b * i;
    }
    
    // do the middle points:
    for (i = first_x + hw + 1; i < last_x - hw; i++) {
        linear_regression(i, smooth, a, b);
        smooth_time_map[i] = a + b * i;
        
#if DEBUG_LOG
        fprintf(dbf, "time_map[%d] = %g, smooth_time_map[%d] = %g\n", 
                i, time_map[i], i, a + b*i);
#endif
        
    }

    // do the last points
    linear_regression(last_x - hw, smooth, a, b);
    for (i = last_x - hw; i <= last_x; i++) {
        smooth_time_map[i] = a + b * i;
    }
    // finally, fill with NOT_MAPPED
    for (i = last_x + 1; i < file0_frames; i++) 
        smooth_time_map[i] = NOT_MAPPED;
}
void test_stiffly_accurate_kinetics(void** state)
{
    // We use the symplectic Crank-Nicolson method to integrate the trajectory
    // of a particle under the influence of a central force. We test that its
    // energy is conserved, and that the integration error converges to zero
    // at second order accuracy.
    ode_integrator_t* I = stiffly_accurate_kinetics_integrator();

    // Reference values.
    real_t T = 400.0;
    real_t X0 = 0.4505440, X1 = 3.223217e-06, X2 = 5.494528e-01;

    int num_trials = 11;
    int num_steps_array[11] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024};
    real_t L2_array[num_trials];
    for (int i = 0; i < num_trials; ++i)
    {
        int num_steps = num_steps_array[i];
        real_t X[3] = {1.0, 0.0, 0.0};
        real_t dt = T / num_steps;

        // Integrate with the given time step.
        real_t t = 0.0;
        for (int j = 0; j < num_steps; ++j)
        {
            bool success = ode_integrator_step(I, dt, &t, X);
            assert_true(success);
        }

        // Compute error norms from reference values.
        real_t L2 = sqrt((X[0]-X0)*(X[0]-X0) + (X[1]-X1)*(X[1]-X1) + (X[2]-X2)*(X[2]-X2));
        L2_array[i] = L2;
    }

    // Compute the convergence rate of the L2 error norm.
    real_t log_n_ratios[num_trials-1], log_L2_ratios[num_trials-1];
    for (int i = 0; i < num_trials-1; ++i)
    {
        log_n_ratios[i] = log(pow(2.0, i));
        log_L2_ratios[i] = log(L2_array[i+1] / L2_array[0]);
    }
    real_t A, B, sigma;
    linear_regression(log_n_ratios, log_L2_ratios, num_trials-1, &A, &B, &sigma);
    real_t L2_conv_rate = -A;
    log_urgent("stiffly accurate kinetics L2 error conv rate = %g\n", L2_conv_rate);
    assert_true(L2_conv_rate >= 0.93);

    // Clean up.
    ode_integrator_free(I);
}
예제 #6
0
파일: mutcheck.c 프로젝트: jttkim/lindevol
int main(int argc, char **argv)
{
  extern char *optarg;
  int          optchar;
  char *treefile_name = NULL, *genomefile_name = NULL, *outfile_name = NULL, *corrfile_name = NULL;
  FILE *treefile, *genomefile, *outfile, *corrfile;
  long genome_generation, tree_generation, i, j, num_trees;
  double tree_d, gen_d, change_rate, m1, m_a, mutation_rate;
  double *tree_dist = NULL, *m_app = NULL;
  double grade, y0, r;
  long num_data;
  PHYLTREE phyltree;
  POPULATION population;
  int ret_code;

  phyl_init_tree(&phyltree);
  while ((optchar = getopt(argc, argv, "hg:t:o:c:m:")) != -1)
  {
    switch (optchar)
    {
    case 'g':
      genomefile_name = optarg;
      break;
    case 't':
      treefile_name = optarg;
      break;
    case 'c':
      corrfile_name = optarg;
      break;
    case 'o':
      outfile_name = optarg;
      break;
    case 'h':
      printf("mutcheck -- analyze apparent mutation rates\n");
      printf("\n");
      printf("Command line usage:\n");
      printf("-g <filename>: Specify genome file (mandatory)\n");
      printf("-t <filename>: Specify tree file (mandatory)\n");
      printf("-o <filename>: Specify name for individual generation's output file\n");
      printf("-c <filename>: Specify file for treedist vs reconstructed dist correlations\n");
      printf("-h: Print this help and exit\n");
      exit (EXIT_SUCCESS);
    }
  }
  if (treefile_name == NULL)
  {
    fprintf(stderr, "no tree file specified -- exit\n");
    exit (EXIT_FAILURE);
  }
  if ((treefile = fopen(treefile_name, "r")) == NULL)
  {
    fprintf(stderr, "failed to open tree file \"%s\" -- exit\n", treefile_name);
    exit (EXIT_FAILURE);
  }
  if (genomefile_name == NULL)
  {
    fprintf(stderr, "No genome file specified -- exit\n");
    fclose(treefile);
    exit (EXIT_FAILURE);
  }
  if ((genomefile = fopen(genomefile_name, "r")) == NULL)
  {
    fprintf(stderr, "Failed to open genome file \"%s\" -- exit\n", genomefile_name);
    fclose(treefile);
    exit (EXIT_FAILURE);
  }
  if (corrfile_name)
  {
    if ((corrfile = fopen(corrfile_name, "w")) == NULL)
    {
      fprintf(stderr, "Failed to open \"%s\" for correlation output -- exit\n", corrfile_name);
      fclose(treefile);
      fclose(genomefile);
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    corrfile = stdout;
    corrfile_name = "stdout";
  }
  if (outfile_name)
  {
    if ((outfile = fopen(outfile_name, "w")) == NULL)
    {
      fprintf(stderr, "mutcheck: Failed to open %s for output -- exit\n", outfile_name);
      fclose(treefile);
      fclose(genomefile);
      if (corrfile_name)
	fclose(corrfile);
      exit (EXIT_FAILURE);
    }
  }
  else
    outfile = NULL;

  while (!feof(genomefile) && !ferror(genomefile) && !feof(treefile) && !ferror(treefile))
  {
    fgets(buf, 256, treefile);
    if ((buf[0] != 'g') || (buf[1] != ' '))
    {
      fprintf(stderr, "Treefile corrupt after generation %ld\n", tree_generation);
      break;
    }
    tree_generation = strtol(buf + 2, NULL, 10);
    fgets(buf, 256, genomefile);
    if ((buf[0] != 'g') || (buf[1] != ' '))
    {
      fprintf(stderr, "Genome file corrupt after generation %ld\n", genome_generation);
      break;
    }
    genome_generation = strtol(buf + 2, NULL, 10);
    fgets(buf, 256, treefile);
    num_trees = strtol(buf, (char **) NULL, 10);
    if (num_trees != 1)
    {
      fprintf(stderr, "%ld trees in generation %ld -- skipping\n", num_trees, tree_generation);
      for (i = 0; i < num_trees; i++)
      {
        phyl_read_tree(treefile, &phyltree);
        phyl_free_tree(&phyltree);
      }
    }
    else
      phyl_read_tree(treefile, &phyltree);
    read_genomes(genomefile, &population);
    if ((num_trees == 1) && (tree_generation == genome_generation))
    {
      if ((tree_dist = (double *) malloc((population.size * population.size - 1) / 2 * sizeof(double))) == NULL)
        fprintf(stderr, "Failed to allocate array of tree distances\n");
      else
      {
        if ((m_app = (double *) malloc(population.size * (population.size - 1) / 2 * sizeof(double))) == NULL)
          fprintf(stderr, "Failed to allocate array of reconstructed distances\n");
        else
        {
          num_data = 0;
          for (i = 0; i < population.size; i++)
          {
            for (j = 0; j < i; j++)
            {
              tree_d = phyl_leafdistance(&phyltree, population.seq[i].name, population.seq[j].name);
              if (tree_d < 0)
              {
                fprintf(stderr, "Generation %ld: Trees and genomes inconsistent: error #%f\n", tree_generation, tree_d);
                break;
              }
              gen_d = diffchar_distance(population.seq[i].genome.length,
                      population.seq[i].genome.g,
                      population.seq[j].genome.length, population.seq[j].genome.g);
              change_rate = gen_d / (population.seq[i].genome.length);
              m1 = 1.0 - 256.0 / 255.0 * change_rate;
              if (m1 > 0.0)
              {
		errno = 0;
                m_a = 1.0 - pow(m1, 1.0 / 2.0 / tree_d);
		if (errno)
		  perror("mutcheck: error in pow()");
		else
		{
		  tree_dist[num_data] = tree_d;
		  m_app[num_data] = m_a;
		  num_data++;
		  if (outfile)
		    fprintf(outfile, "%f %f\n", tree_d, m_a);
		}
              }
              else if (outfile)
                fprintf(outfile, "# Negative base operand to exponentiation: %f)\n", m1);
            }
            if (j < i)
              break;
          }
          if ((ret_code = linear_regression(num_data, tree_dist, m_app, &grade, &y0, &r)) < 0)
          {
            fprintf(stderr, "Error #%d in linear regression\n", ret_code);
          }
          else
          {
            mutation_rate = 1.0 - exp(grade);
            if (corrfile)
              fprintf(corrfile, "%ld %f %f\n", tree_generation, grade, r);
          }
          free(m_app);
        }
        free(tree_dist);
      }
    }
    phyl_free_tree(&phyltree);
    free_population(&population);
#ifdef MEMDEBUG
    print_MemdebugStatistics();
#endif
  }
  if (corrfile != stdout)
    fclose(corrfile);
  if (outfile)
    fclose(outfile);
  fclose(treefile);
  fclose(genomefile);
  return (EXIT_SUCCESS);
}
예제 #7
0
파일: sucwt.c 프로젝트: gwowen/seismicunix
int
main(int argc, char **argv)
{

	int i,j,k;		/* counters */
	int ns=0;		/* number of samples in input data */
	int nwavelet=1024;	/* number of samples in mother wavelet */

	float base=0.0;		/* base */
	float first=0.0;	/* first exponent */
	float expinc=0.0;	/* exponent increment */
	float last=0.0;		/* last exponent */
	float exponent=0.0;	/* each exponent */
	float maxscale=0.0;	/* maximum scale value */
	float minscale=0.0;	/* minimum scale value */

	float x=0.0;
	float dx=0.0;		/* xvalues incr */

	float xmin=0.0;		/* last xvalues - first vval */
	float xcenter=0.0;	/* x value of center of wavelet */
	float xmax=0.0;		/* last xvalues - first vval */
	float sigma=1.0;	/* sharpening parameter */

	float waveletinc=0.0;		/* wavelet interval */
	float fmin=0.0;		/* min, max filt value (debug) */
	float *xvalues=NULL;	/* wavelet xvalues */
	float **filt=NULL;	/* filter used for each conv */

	float *f=NULL;		/* scratch for filter fliplr */
	float *sucwt_buff=NULL;	/* scratch for convolution */
	float *scales=NULL;	/* scales */
	float *waveletsum=NULL;	/* cumulative sum of wavelet */

	float *rt=NULL;		/* temp data storage */
	float *qt=NULL;		/* temp hilbert transformed data storage */
	float **tmpdata=NULL;	/* temp data storage */

	int wtype=0;		/* type of wavelet selected */
	float *wavelet=NULL;	/* pointer to data constituting the wavelet */

	int verbose=0;		/* verbose flag */
	int *index=NULL;	/* wavelet subscripts to use for filter */
	int *nconv=NULL;	/* length of each filter */
	int nscales=0;		/* number of scales */

	int holder=0;		/* =1 compute the Holder-Lipschitz regularity */
	float divisor=1.0;	/* divisor used in Holder exponent calculation*/

	/* Initialize */
	initargs(argc, argv);
	requestdoc(1);


	/* Get parameters */
	if(!getparfloat("base",&base))			base = 10.;
	if(!getparfloat("first",&first))		first = -1.0;
	if(!getparfloat("expinc",&expinc))			expinc = 0.01;
	if(!getparfloat("last",&last))			last = 1.5;

	if(!getparint("wtype",&wtype))			wtype = 0;
	if(!getparint("nwavelet",&nwavelet))		nwavelet = 1024;
	if(!getparfloat("xmin",&xmin))			xmin = -20.0;
	if(!getparfloat("xcenter",&xcenter))		xmin = 0.0;
	if(!getparfloat("xmax",&xmax))			xmax = 20.0;
	if(!getparfloat("sigma",&sigma))		sigma = 1.0;

	if(!getparint("holder",&holder))		holder = 0;
	if(!getparfloat("divisor",&divisor))		divisor = 1.0;

	if(!getparint("verbose",&verbose))		verbose = 0;

	if(verbose)
	 warn("base=%f, first=%f, expinc=%f, last=%f",base,first,expinc,last);


	/* Allocate space */
	xvalues = ealloc1float(nwavelet);
	wavelet = ealloc1float(nwavelet);
	memset((void *) xvalues, 0, nwavelet*FSIZE);
	memset((void *) wavelet, 0, nwavelet*FSIZE);

	/* Compute wavelet */
	if (wtype == 0 ) { /* so far only Mex. Hat function */
		MexicanHatFunction(nwavelet, xmin, xcenter,
					xmax, sigma, wavelet);
	} else {
		err("%d  type of wavelet not yet implemented",wtype); 
	}

	/* wavelet increment */
	waveletinc = (xmax - xmin)/(nwavelet - 1);

	/* verbose  warning */
	if(verbose)
	 warn("xmin=%f, xmax=%f, nwavelet=%d, waveletinc=%f",
			xmin,xmax,nwavelet,waveletinc);

	/* form xvalues[] array */
	for(i=0,x=xmin; i<nwavelet; ++i,x+=waveletinc) xvalues[i] = x;

	xvalues[nwavelet-1] = xmax;

	/* compute scales */
	scales = ealloc1float(SHRT_MAX);
	memset((void *) scales, 0, SHRT_MAX*FSIZE);

	exponent = first;
	x = 0;
	nscales = 0;
	minscale = pow(base,first);
	maxscale = pow(base,last);
	while(x <= maxscale) {
		x = pow(base,exponent);
		scales[nscales] = x;
		exponent+=expinc;
		++nscales;

		if(nscales == SHRT_MAX)
			err("Too many scales, change params and re-run\n");
	}
	--nscales;


	/* Allocate space */
	nconv = ealloc1int(nscales);
	index = ealloc1int(nwavelet);
	waveletsum = ealloc1float(nwavelet);
	filt = ealloc2float(nwavelet,nscales);
	f = ealloc1float(nwavelet);

	/* Zero out arrays */
	memset((void *) nconv, 0, nscales*ISIZE);
	memset((void *) index, 0, nwavelet*ISIZE);
	memset((void *) waveletsum, 0, nwavelet*FSIZE);
	memset((void *) filt[0], 0, nwavelet*nscales*FSIZE);
	memset((void *) f, 0, nwavelet*FSIZE);

	/* Form difference of xvalues */
	for(i=nwavelet-1; i>=0; --i)
		xvalues[i] = xvalues[i] - xvalues[0];	

	dx = xvalues[1];
	xmax = xvalues[nwavelet-1];

	/* verbose warning */
	if(verbose) {
		warn("first xvalues=%f, last xvalues=%f",
				xvalues[0],xvalues[nwavelet-1]);
		warn("dx=%f, xmax=%f",dx,xmax);
	}
	
	/* waveletsum is cumulative sum of wavelet multipled by dx */
	fmin = 0;

	for(i=0; i<nwavelet; ++i) {
		fmin += wavelet[i];
		waveletsum[i] = fmin * dx;
	}

	/* Build filters from summed wavelet */
	for(i=0; i<nscales; ++i) {
		nconv[i] = 1 + (int)(scales[i] * xmax);

		for(j=0; j<nconv[i]; ++j)
			index[j] = 1 + j / (scales[i] * dx);

		for(j=0; j<nconv[i]; ++j)
			f[j] = waveletsum[index[j]-1];

		/* flip left right */
		for(j=0,k=nconv[i]-1; j<nconv[i]; ++j,--k)
			filt[i][j] = f[k];
	}

	/* Verbose warning */
	if(verbose) {
		warn("Convolution Lengths");
		for(i=0; i<nscales; ++i) warn("%d ",nconv[i]);
	}
	if(verbose) warn("%d scales will be used for transforms",nscales);

	/* Get information from first trace */
	if(!gettr(&tr))
		err("Cannot get first trace\n");
	ns = tr.ns;

	/* Allocate temporary storage space */
	rt = ealloc1float(ns);
	qt = ealloc1float(ns);
	tmpdata = ealloc2float(nscales,ns);

	/* Zero out rt and qt */
	memset((void *) rt, 0, ns*FSIZE);
	memset((void *) qt, 0, ns*FSIZE);

	/* Alloc sucwt_buffer for longest convolution */
	sucwt_buff = ealloc1float(ns+nconv[nscales-1]+1);
	
	do {  /* main loop over traces */

		outtr.d2 = waveletinc;
		outtr.f2 = minscale;

		memcpy((void *)&outtr,(const void *)&tr,HDRBYTES);

		/* Apply filters to produce wavelet transform */
		for(i=0; i<nscales; ++i) { /* loop over scales */

			for(j=0; j<ns+nconv[nscales-1]+1; ++j)
			sucwt_buff[j] = 0;

			/* convolve wavelet with data */
			conv(ns,0,tr.data,nconv[i],0,
					filt[i],ns,0,sucwt_buff);

			for(j=0; j<ns; ++j) 
				rt[j] = sucwt_buff[j+nconv[i]/2-1];

			for(j=ns-1; j>0; --j) 
				rt[j] = rt[j] - rt[j-1];

			for(j=0; j<ns; ++j)
				rt[j] = -sqrt(scales[i]) * rt[j];

				/* form the hilbert transform of rt */
				hilbert(ns,rt,qt);

			/* If not holder, then output envelope */
			if (!holder) {
				
				for (j=0 ; j<ns; ++j) {			
			  		outtr.data[j] = sqrt(rt[j]*rt[j] 
						               + qt[j]*qt[j]);
				}

				outtr.cdpt = i + 1;
				puttr(&outtr);
			} else {
				/* compute the modulus */
				for (j=0 ; j<ns; ++j) {			
			  		tmpdata[j][i] = sqrt(rt[j]*rt[j] + qt[j]*qt[j]);
				}

			}
		}


		if (holder) { /* compute the Holder regularity traces */
			float *x;
			float *y;
			float lrcoeff[4];

			x = ealloc1float(nscales);
			y = ealloc1float(nscales);
			
	                /* Compute an estimate of the Lipschitz (Holder)
			* regularity. Following Mallat (1992)	
                        *				
                        * ln | Wf(x,s)| <  ln C + alpha * ln|s|
                        *					
                        * alpha here is the Holder or Lipschitz exponent
                        * s is the length scale, and Wf(x,s) is f in the
                        * wavelet basis.			         
                        *					         
			* Here we merely fit a straight line		 
			* through the log-log graph of the of our wavelet
			* transformed data and return the slope as      
			* the regularity measure. 			
                        *					         
			*/

                	for ( j =0 ; j< ns ; ++j ) {
				int icount=0;
                        	x[0]=0;
                        	for ( i = 1 ; i < nscales ; ++i ) {
				
					
			          /* We stay away from values that will make */
				  /*  NANs in the output */
				  if ((i>1) && 
				      (tmpdata[j][i-1] - tmpdata[j][1] > 0.0)) {
                               		y[icount] = log(ABS(tmpdata[j][i]
                                     	              - tmpdata[j][1]));
                                			x[icount] = log(scales[i]-scales[1]);
						
						++icount;
					}

                        	}
				--icount;

				/* straight line fit, return slope */
				if ((icount> 10) && (divisor==1.0) ) {
                        	   linear_regression(y, x, icount, lrcoeff);
                        	   /* lrcoeff[0] is the slope of the line */
				   /* which is the Holder (Lipschitz) */
				   /* exponent */

                        	   outtr.data[j] = lrcoeff[0];

				} else  if ((icount> 10) && (divisor>1.0) ) {

				   float maxalpha=0.0;
				   float interval=icount/divisor;

				   for ( k = interval; k < icount; k+=interval){
                        	   	   linear_regression(y, x, k, lrcoeff);
					   maxalpha = MAX(lrcoeff[0],maxalpha);
					}
				   outtr.data[j] = maxalpha;		

				} else if ((icount < 10) && (divisor>=1.0)) {
				   outtr.data[j] = 0.0;		
				} else if ( divisor < 1.0 ) {
				   err("divisor = %f < 1.0!", divisor);	
				}
				



                	}

			puttr(&outtr); /* output holder regularity traces */
		}
	} while(gettr(&tr));

	return(CWP_Exit());
}
예제 #8
0
void a1(void)
{
  int N = 3,
      M = 1;
  data *dat = (data*) malloc(N*sizeof(data));
  dat[0] = (data) { .val = 299793.0, .delta = 2.0 };
  dat[1] = (data) { .val = 299792.0, .delta = 4.5 };
  dat[2] = (data) { .val = 299782.0, .delta = 25.0 };

  double avg   = average_value(N, dat),
         sig_i = sigma_square_intern(N, dat),
         sig_e = sigma_square_extern(M, N, dat);

  printf("c_avg   = %f\n", avg);
  printf("sigma_i = %f\n", sqrt(sig_i));
  printf("sigma_e = %f\n", sqrt(sig_e));
}

void a2(void)
{
  int N;
  measurement *m = read_measurements("dat/a2.txt", &N);
  double a, b, sig_a, sig_b, chi;

  printf("\nLinear regression I = b*U:\n");
  linear_regression(N, m, NULL, &b, NULL, &sig_b);
  chi = chi_square_(N, m, 0, b);
  printf("b = %f +/- %f, chi = %f\n", b, sqrt(sig_b)/2, sqrt(chi));

  printf("\nLinear regression I = a + b*U:\n");
  linear_regression(N, m, &a, &b, &sig_a, &sig_b);
  chi = chi_square_(N, m, a, b);
  printf("a = %f +/- %f, b = %f +/- %f, chi = %f\n", a, sqrt(sig_a)/2, b, sqrt(sig_b)/2, sqrt(chi));
}

void a3(void)
{
  // order of polynoms + 1
  int N[5] = {3, 5, 9, 13, 17};

  // output function (%i = current N)
  char *output_p_gp  = "results/a3/poly-%i.gp",
       *output_p_txt = "results/a3/poly-%i.txt",
       *output_l_dat = "results/a3/legendre-%i.dat",
       *output_l_txt = "results/a3/legendre-%i.txt";

  // read data
  matrix dat = read_data("dat/a3.txt");

  int i;
  for (i = 0; i < sizeof(N)/sizeof(int); i++)
  {
    //
    // use polynoms
    //
    matrix F = init_F(dat, N[i], &polynom);
    vector b = init_b(dat, N[i], &polynom);

    // solve system of linear equations
    vector x = solve_gauss(F,b);

    char fp[100];

    // parameter output
    snprintf(fp, sizeof(fp), output_p_txt, N[i]-1);
    printf("Opening file %s...\n", fp);
    FILE *file = fopen(fp, "w+");
    vector_fprint(file, x);
    fclose(file);

    // gnuplot output
    snprintf(fp, sizeof(fp), output_p_gp, N[i]-1);
    printf("Opening file %s...\n", fp);
    file = fopen(fp, "w+");
    fprintf(file, "plot ");
    int k;
    for (k = 0; k < x.N; k++)
    {
      fprintf(file, "%e * x**%i", VectorGET(x,k), k);
      if (k < x.N-1)
        fprintf(file, " + ");
    }
    fprintf(file, "\n");
    fclose(file);

    //
    // Use legendre polynoms
    //
    F = init_F(dat, N[i], &legendre_polynom);
    b = init_b(dat, N[i], &legendre_polynom);

    // solve system of linear equations
    x = solve_gauss(F,b);

    // parameter output
    snprintf(fp, sizeof(fp), output_l_txt, N[i]-1);
    printf("Opening file %s...\n", fp);
    file = fopen(fp, "w+");
    vector_fprint(file, x);

    // "plot" data for legendre polynoms
    snprintf(fp, sizeof(fp), output_l_dat, N[i]-1);
    printf("Opening file %s...\n", fp);
    file = fopen(fp, "w+");
    double r  = -1.0,
           dr = 0.01;
    while (r <= 1.0)
    {
      double sum = 0;
      for (k = 0; k < x.N; k++)
      {
        sum += VectorGET(x,k) * legendre_polynom(k,r);
      }
      fprintf(file, "%f %e\n", r, sum);
      r += dr;
    }
    fclose(file);
    file = NULL;
  }
}

int main()
{

  //a1();
  //a2();
  a3();

  return 0;
}
예제 #9
0
파일: treecorr.c 프로젝트: jttkim/lindevol
int main(int argc, char **argv)
{
  extern char *optarg;
  int          optchar;
  char *treefile_name = NULL, *genomefile_name = NULL, *outfile_name = NULL, *corrfile_name = NULL, *mutfile_name = NULL;
  FILE *treefile, *genomefile, *outfile, *corrfile, *mutfile;
  long genome_generation, tree_generation, i, j, num_trees;
  double tree_d, rec_d, rec_d1, change_rate, mutation_rate;
  double *tree_dist = NULL, *reconst_dist = NULL;
  double lambda, y0, r;
  long num_data;
  PHYLTREE phyltree;
  POPULATION population;
  int ret_code;

  phyl_init_tree(&phyltree);
  while ((optchar = getopt(argc, argv, "hg:t:o:c:m:")) != -1)
  {
    switch (optchar)
    {
    case 'g':
      genomefile_name = optarg;
      break;
    case 't':
      treefile_name = optarg;
      break;
    case 'c':
      corrfile_name = optarg;
      break;
    case 'm':
      mutfile_name = optarg;
      break;
    case 'o':
      outfile_name = optarg;
      break;
    case 'h':
      printf("treecorr -- check correlation between corrected\n");
      printf("    edit or hamming diatance and true tree distance\n");
      printf("\n");
      printf("Command line usage:\n");
      printf("-g <filename>: Specify genome file (mandatory)\n");
      printf("-t <filename>: Specify tree file (mandatory)\n");
      printf("-o <filename>: Specify base name for individual generation's output file\n");
      printf("-c <filename>: Specify file for treedist vs reconstructed dist correlations\n");
      printf("-m <filename>: Specify file for reconstructed mutation rates\n");
      printf("-h: Print this help and exit\n");
      exit (EXIT_SUCCESS);
    }
  }
  if (treefile_name == NULL)
  {
    fprintf(stderr, "no tree file specified -- exit\n");
    exit (EXIT_FAILURE);
  }
  if ((treefile = fopen(treefile_name, "r")) == NULL)
  {
    fprintf(stderr, "failed to open tree file \"%s\" -- exit\n", treefile_name);
    exit (EXIT_FAILURE);
  }
  if (genomefile_name == NULL)
  {
    fprintf(stderr, "No genome file specified -- exit\n");
    fclose(treefile);
    exit (EXIT_FAILURE);
  }
  if ((genomefile = fopen(genomefile_name, "r")) == NULL)
  {
    fprintf(stderr, "Failed to open genome file \"%s\" -- exit\n", genomefile_name);
    fclose(treefile);
    exit (EXIT_FAILURE);
  }
  if (corrfile_name)
  {
    if ((corrfile = fopen(corrfile_name, "w")) == NULL)
    {
      fprintf(stderr, "Failed to open \"%s\" for correlation output -- exit\n", corrfile_name);
      fclose(treefile);
      fclose(genomefile);
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    corrfile = stdout;
    corrfile_name = "stdout";
  }
  if (mutfile_name)
  {
    if ((mutfile = fopen(mutfile_name, "w")) == NULL)
    {
      fprintf(stderr, "Failed to open \"%s\" for mutation output -- exit\n", mutfile_name);
      fclose(treefile);
      fclose(genomefile);
      if (corrfile != stdout)
        fclose(corrfile);
      exit (EXIT_FAILURE);
    }
  }
  else
    mutfile = NULL;
  while (!feof(genomefile) && !ferror(genomefile) && !feof(treefile) && !ferror(treefile))
  {
    fgets(buf, 256, treefile);
    if ((buf[0] != 'g') || (buf[1] != ' '))
    {
      fprintf(stderr, "Treefile corrupt after generation %ld\n", tree_generation);
      break;
    }
    tree_generation = strtol(buf + 2, NULL, 10);
    fgets(buf, 256, genomefile);
    if ((buf[0] != 'g') || (buf[1] != ' '))
    {
      fprintf(stderr, "Genome file corrupt after generation %ld\n", genome_generation);
      break;
    }
    genome_generation = strtol(buf + 2, NULL, 10);
    fgets(buf, 256, treefile);
    num_trees = strtol(buf, (char **) NULL, 10);
    if (num_trees != 1)
    {
      fprintf(stderr, "%ld trees in generation %ld -- skipping\n", num_trees, tree_generation);
      for (i = 0; i < num_trees; i++)
      {
        phyl_read_tree(treefile, &phyltree);
        phyl_free_tree(&phyltree);
      }
    }
    else
      phyl_read_tree(treefile, &phyltree);
    read_genomes(genomefile, &population);
    if ((num_trees == 1) && (tree_generation == genome_generation))
    {
      if ((tree_dist = (double *) malloc((population.size * population.size - 1) / 2 * sizeof(double))) == NULL)
        fprintf(stderr, "Failed to allocate array of tree distances\n");
      else
      {
        if ((reconst_dist = (double *) malloc(population.size * (population.size - 1) / 2 * sizeof(double))) == NULL)
          fprintf(stderr, "Failed to allocate array of reconstructed distances\n");
        else
        {
          if (outfile_name)
          {
            sprintf(buf, "%s-%05ld.gpd", outfile_name, tree_generation);
            outfile = fopen(buf, "w");
	    fprintf(outfile, "# generation %ld\n", tree_generation);
          }
          num_data = 0;
          for (i = 0; i < population.size; i++)
          {
            for (j = 0; j < i; j++)
            {
              tree_d = phyl_leafdistance(&phyltree, population.seq[i].name, population.seq[j].name);
              if (tree_d < 0)
              {
                fprintf(stderr, "Generation %ld: Trees and genomes inconsistent: error #%f\n", tree_generation, tree_d);
                break;
              }
              rec_d = diffchar_distance(population.seq[i].genome.length,
                      population.seq[i].genome.g,
                      population.seq[j].genome.length, population.seq[j].genome.g);
              change_rate = rec_d / (population.seq[i].genome.length);
              rec_d1 = 1.0 - 256.0 / 255.0 * change_rate;
              if (rec_d1 > 0.0)
              {
                rec_d = log(rec_d1);
                tree_dist[num_data] = tree_d;
                reconst_dist[num_data] = rec_d;
                num_data++;
                if (outfile)
                  fprintf(outfile, "%f %f\n", tree_d, rec_d);
              }
              else if (outfile)
                fprintf(outfile, "# Infinite distance (log operand: %f)\n", rec_d1);
            }
            if (j < i)
              break;
          }
          if (outfile_name && outfile)
            fclose(outfile);
          if ((ret_code = linear_regression(num_data, tree_dist, reconst_dist, &lambda, &y0, &r)) < 0)
          {
            fprintf(stderr, "Error #%d in linear regression\n", ret_code);
          }
          else
          {
            mutation_rate = 1.0 - exp(lambda);
            if (corrfile)
              fprintf(corrfile, "%ld %f\n", tree_generation, r);
            if (mutfile)
              fprintf(mutfile, "%ld %f\n", tree_generation, mutation_rate);
          }
          free(reconst_dist);
        }
        free(tree_dist);
      }
    }
    phyl_free_tree(&phyltree);
    free_population(&population);
#ifdef MEMDEBUG
    print_MemdebugStatistics();
#endif
  }
  if (mutfile)
    fclose(mutfile);
  if (corrfile != stdout)
    fclose(corrfile);
  fclose(treefile);
  fclose(genomefile);
  return (EXIT_SUCCESS);
}
예제 #10
0
    void ICharacter::calculateStats ()
    {
        boost::unique_lock<boost::mutex> statsLock(m_stats_mutex);

        boost::mutex::scoped_lock property_lock(m_property_mutex);

        /// SET BASE STATS AND RECALCULATE
        m_MA = std::make_pair(0,0);
        m_PA = std::make_pair(0,0);
        m_PAbs = 0;
        m_MAbs = 0;
        m_PD = m_property->PhysicalDefense;
        m_MD = m_property->MagicalDefense;
        m_BR = m_property->BlockRatio;
        m_CR = 0;
        m_PR = m_property->ParryRatio;
        m_HR = m_property->HitRatio;
        m_PBalance = 0;
        m_MBalance = 0;
        m_PRate = 0;
        m_MRate = 0;
        m_AD = 0;

        float wlkspeed = m_property->WalkSpeed;
        float runspeed = m_property->RunSpeed;
        float bskspeed = m_property->BersekSpeed;

        property_lock.unlock();

        bool hasWall = false;
        uint32_t curWallHP = m_Effects[STAT_WALL_HP];

        m_Effects.clear();

        short speed_percent = 0;
        short hp_percent = 0;
        short mp_percent = 0;
        short pr_percent = 0;
        short hr_percent = 0;
        short pd_percent = 0;
        short md_percent = 0;

        std::vector<std::pair<CHAR_STATS,int32_t> > bonus;

        calculatePreStats(bonus);

        boost::mutex::scoped_lock buff_lock(m_buff_mutex);

        for ( std::map<uint32_t,Buff>::const_iterator k = m_buff_list.begin(); k != m_buff_list.end(); ++k)
        {
            for (Skill::buff_const_iterator j = k->second.skill->buff_begin(); j != k->second.skill->buff_end(); ++j)
            {
                switch(j->ID)
                {
                case BUFF_CRITICAL_INC:
                    m_CR += j->Arg[0];
                    break;
                case BUFF_SPEED_INC:
                case BUFF_SPEED_INC2:
                case BUFF_SPEED_INC3:
                    speed_percent += j->Arg[0];
                    break;
                case BUFF_PARRY_INC:
                    m_PR += j->Arg[0];
                    pr_percent += j->Arg[1];
                    break;
                case BUFF_PARRY_DEC:
                    m_PR -= j->Arg[0];
                    break;
                case BUFF_HIT_INC:
                    m_HR += j->Arg[0];
                    hr_percent += j->Arg[1];
                    break;
                case BUFF_HIT_DEC:
                    m_HR -= j->Arg[0];
                    break;
                case BUFF_HP_INC:
                    m_MaxHP += j->Arg[0];
                    hp_percent += j->Arg[1];
                    break;
                case BUFF_MP_INC:
                    m_MaxMP += j->Arg[0];
                    mp_percent += j->Arg[1];
                    break;
                case BUFF_RANGE_INC:
                    m_AD += j->Arg[0];
                    break;
                case BUFF_DAMAGE_INC:
                    m_PRate += j->Arg[0];
                    m_MRate += j->Arg[0];
                    break;
                case BUFF_INT_INC:
                case BUFF_STR_INC:
                case BUFF_SHIELD_PWR_4_DAMAGE:
                    calculateBuffEffects(bonus,*j);
                    break;
                case BUFF_REINCARNATION:
                    m_Effects[STAT_HP_RGN] += j->Arg[0];
                    m_Effects[STAT_MP_RGN] += j->Arg[1];
                    break;
                case BUFF_IGNORE_DEFENSE:
                    m_Effects[STAT_IGD] += j->Arg[0];
                    break;
                case BUFF_CRIT_PARRY_INC:
                    m_Effects[STAT_CPR] += j->Arg[0];
                    break;
                case BUFF_GOLD_DROP_INC:
                    m_Effects[STAT_GOLD_DROP] += j->Arg[0];
                    break;
                case BUFF_MAGICOPTION_LUCK_INC:
                    m_Effects[STAT_MOL] += j->Arg[0];
                    break;
                case BUFF_ENCHANT_LUCK_INC:
                    m_Effects[STAT_ETL] += j->Arg[0];
                    break;
                case BUFF_MP_ABSORB:
                    m_Effects[STAT_MP_ABSORB] += j->Arg[0];
                    break;
                case BUFF_DAMAGE_PWR_INC:
                    m_PA.first += j->Arg[0];
                    m_PA.second += j->Arg[0];

                    m_MA.first += j->Arg[1];
                    m_MA.second += j->Arg[1];
                    break;
                case BUFF_DETECT:
                case BUFF_DETECT_V2:
                    //(5 Stealth) (6 Invisible) (7 All)
                    //Max level
                    break;
                case BUFF_HEAL_INC:
                    m_Effects[STAT_HP_HEAL] += j->Arg[0];
                    m_Effects[STAT_MP_HEAL] += j->Arg[1];
                    break;
                case BUFF_ABSORB_WALL:
                    hasWall = true;
                    m_Effects[STAT_WALL] = j->Arg[0] == WALL_TYPE_PHYSICAL;
                    m_Effects[STAT_WALL_MAX] = j->Arg[1];
                    m_Effects[STAT_WALL_RATE] = j->Arg[3];
                    m_Effects[STAT_WALL_ID] = k->first;
                    break;
                case BUFF_BLOCK_INC:
                    //BLOCK TYPE +0 (15 ALL) (11 Magic %) (7 Physical %)
                    //BLOCK RATE +1
                    m_BR += j->Arg[1];
                    break;
                case BUFF_DAMAGE_REFLECT:
                    //PROBABILITY [%]
                    //PHY DAMAGE RETURNED [%]
                    //MAG DAMAGE RETURNED [%]
                    //RETURN RANGE
                    break;
                case BUFF_ABSORB:
                    //TYPE (3 - Physical Absorb) (12 & 15 - Absorb all) (4 Physical) (8 Magical) (6 Physical ranged)
                    //Amount (%)
                    //0
                    break;
                case BUFF_DEFENSE_INC:
                    m_PD += j->Arg[0];
                    m_MD += j->Arg[1];
                    //Caster Range
                    break;
                case BUFF_DEFENSE_DEC:
                    pd_percent -= j->Arg[0];
                    md_percent -= j->Arg[1];
                    break;
                case BUFF_DAMAGE_DEC:
                    m_PRate -= j->Arg[0];
                    m_MRate -= j->Arg[1];
                    break;
                case BUFF_HP_DEC:
                    //Duration
                    //0
                    hp_percent -= j->Arg[2];
                    //2
                    break;
                default:
                    break;
                }
            }
        }

        if (hasWall)
        {
            uint32_t wallMax = m_Effects[STAT_WALL_MAX];

            if (curWallHP > wallMax)
                m_Effects[STAT_WALL_HP] = wallMax;
        }

        buff_lock.unlock();

        for (std::vector<std::pair<CHAR_STATS,int32_t> >::const_iterator it = bonus.begin(); it != bonus.end(); ++it)
        {
            switch(it->first)
            {
            case STAT_HP_PERCENT:
                hp_percent += it->second;
                break;
            case STAT_HR_PERCENT:
                hr_percent += it->second;
                break;
            case STAT_MP_PERCENT:
                mp_percent += it->second;
                break;
            case STAT_PR_PERCENT:
                pr_percent += it->second;
                break;
            default:
                break;
            }
        }

        calculatePostStats();

        if (hp_percent)
            m_MaxHP = linear_regression(m_MaxHP,hp_percent);

        if (m_HP > m_MaxHP)
            m_HP = m_MaxHP;

        if (mp_percent)
            m_MaxMP = linear_regression(m_MaxMP,mp_percent);

        if (m_MP > m_MaxMP)
            m_MP = m_MaxMP;

        if (pr_percent)
            m_PR = linear_regression(m_PR,pr_percent);

        if (hr_percent)
            m_HR = linear_regression(m_HR,hr_percent);

        if (pd_percent)
            m_PD = linear_regression(m_PD,pd_percent);

        if (md_percent)
            m_MD = linear_regression(m_MD,md_percent);

        if (speed_percent)
        {
            wlkspeed = linear_regression(wlkspeed,speed_percent);
            runspeed = linear_regression(runspeed,speed_percent);
            bskspeed = linear_regression(bskspeed,speed_percent);
        }

        if (IsBerserk())
        {
            wlkspeed *=2;
            runspeed *=2;
            bskspeed *=2;

            m_PA.first *= 2;
            m_PA.second *= 2;
            m_MA.first *= 2;
            m_MA.second *= 2;
        }

        m_WalkSpeed = wlkspeed;
        m_RunSpeed = runspeed;
        m_BerserkSpeed = bskspeed;

        calculateStatus();

        statsLock.unlock();

        if (!signal_stats.empty())
            signal_stats();

        if (!signal_speed.empty())
            signal_speed(m_WalkSpeed,m_RunSpeed);
    }
	/* main routine */
	int main(int argc, char *argv[]){

	FILELog::ReportingLevel() = logINFO;
	VARIABLES vars;
	vars = commandline_input(argc, argv);
	clock_t init, final;
		
	int number_of_particles = vars.num; 
	double timestep = vars.dt;
	bool use_T2 = vars.use_T2; // = false (no T2 decay), = true (T2 decay)
	int num_of_repeat = vars.num_of_repeat; //Number of times to repeat simulation. For every repeat all data is flushed and we start the simulation again.
	int number_of_timesteps; number_of_timesteps = (int)ceil(vars.gs/timestep); 	
	
	double permeability = 0.0;
	double radius = .00535;
	double d = sqrt( 2.0*PI*radius*radius/( sqrt(3.0)*.79 ) );
	//double lattice_size = 0.00601922026995422789215053328651;
	double grad_duration = 4.5;
	double D_extra = 2.5E-6;
	double D_intra = 1.0E-6;
	double T2_e = 200;
	double T2_i = 200;
		
	FILE_LOG(logINFO) << "f = " << 2.0*PI*radius*radius/(sqrt(3.0)*d*d) << std::endl;
		
	Vector3 xhat(1.0,0.0,0.0);
	Vector3 yhat(0.0,1.0,0.0);
	Vector3 zhat(0.0,0.0,1.0);		
		
	Lattice<Cylinder_XY> lattice(D_extra, T2_e, permeability);
	lattice.setLatticeVectors(d,2.0*d*0.86602540378443864676372317075294,d,xhat,yhat,zhat);
	lattice.addBasis(Cylinder_XY(d/2.0, 0.0,  radius,  T2_i, D_intra, 1));
	lattice.addBasis(Cylinder_XY(0.0, d*0.86602540378443864676372317075294,  radius,  T2_i, D_intra, 2));
	lattice.addBasis(Cylinder_XY(d/2.0, 2.0*d*0.86602540378443864676372317075294,  radius,  T2_i, D_intra, 3));
	lattice.addBasis(Cylinder_XY(d, d*0.86602540378443864676372317075294,  radius,  T2_i, D_intra, 4));
	


	double gspacings [] = { 8.0 , 10.5 , 14.0 , 18.5 , 24.5 , 32.5 , 42.5 , 56.5 };
	double bvals [] = {108780, 154720, 219040, 301730, 411980, 558990, 742420, 1000000 };
	double G [9];

	for (int kk = 0; kk < num_of_repeat; kk++) {

	vector<PGSE> measurements_x;
	vector<PGSE> measurements_y;
	vector<PGSE> measurements_z;

	for (int i = 0; i < 8; i++){
		double echo_time = 2.0*grad_duration + gspacings[i];
		G[0] = 0.0;
		G[i+1] = sqrt(bvals[i]/(GAMMA*GAMMA*grad_duration*grad_duration*(grad_duration + gspacings[i] - (grad_duration/3.0))));
		measurements_x.push_back(PGSE(grad_duration,gspacings[i], timestep, G[0], echo_time, number_of_particles, xhat));
		measurements_y.push_back(PGSE(grad_duration,gspacings[i], timestep, G[0], echo_time, number_of_particles, yhat));
		measurements_z.push_back(PGSE(grad_duration,gspacings[i], timestep, G[0], echo_time, number_of_particles, zhat));
		measurements_x.push_back(PGSE(grad_duration,gspacings[i], timestep, G[i+1], echo_time, number_of_particles, xhat));
		measurements_y.push_back(PGSE(grad_duration,gspacings[i], timestep, G[i+1], echo_time, number_of_particles, yhat));
		measurements_z.push_back(PGSE(grad_duration,gspacings[i], timestep, G[i+1], echo_time, number_of_particles, zhat));
	
	}
	
	vector<double> lnsignal(2);
	vector<double> b(2);
	

	
	cout << " trial = " << kk << endl;
		Particles ensemble(number_of_particles,timestep, use_T2);
		lattice.initializeUniformly(ensemble.getGenerator() , ensemble.getEnsemble() );
		
		for (int k = 0; k < measurements_x.size();k++){
			measurements_x[k].updatePhase(ensemble.getEnsemble(), 0.0);
			measurements_y[k].updatePhase(ensemble.getEnsemble(), 0.0);
			measurements_z[k].updatePhase(ensemble.getEnsemble(), 0.0);
		}
		
		for (int i = 1; i <= number_of_timesteps; i++){
			ensemble.updateposition(lattice);
			for (int k = 0; k < measurements_x.size();k++){
				measurements_x[k].updatePhase(ensemble.getEnsemble(), i*timestep);
				measurements_y[k].updatePhase(ensemble.getEnsemble(), i*timestep);
				measurements_z[k].updatePhase(ensemble.getEnsemble(), i*timestep);
			}
		}
		
		
		for (int i = 0; i < 8*2; i+=2){
			
			double ADCx, ADCy, ADCz, diff_time;
			
			lnsignal[0] = log(measurements_x[i].get_signal());
			b[0] = 	measurements_x[i].get_b();
			lnsignal[1] = log(measurements_x[i+1].get_signal());
			b[1] = 	measurements_x[i+1].get_b();
			ADCx = -1.0*linear_regression(lnsignal,b);
			
			//std::cout << b[0] << " " << lnsignal[0] << " " << b[1] << " " << lnsignal[1] << " ";
			lnsignal[0] = log(measurements_y[i].get_signal());
			b[0] = 	measurements_y[i].get_b();
			lnsignal[1] = log(measurements_y[i+1].get_signal());
			b[1] = 	measurements_y[i+1].get_b();
			ADCy = -1.0*linear_regression(lnsignal,b);
			//std::cout << b[0] << " " << lnsignal[0] << " " << b[1] << " " << lnsignal[1] << " ";
			lnsignal[0] = log(measurements_z[i].get_signal());
			b[0] = 	measurements_z[i].get_b();
			lnsignal[1] = log(measurements_z[i+1].get_signal());
			b[1] = 	measurements_z[i+1].get_b();
			ADCz = -1.0*linear_regression(lnsignal,b);
			//std::cout << b[0] << " " << lnsignal[0] << " " << b[1] << " " << lnsignal[1] << std::endl;
			
			diff_time = measurements_x[i].get_DT();
			std::cout << i << " " << diff_time << " " << ADCx << " " << ADCy << " " << ADCz << " " << b[1] << " " << G[1] << std::endl; 
			
		}
			
	}
		

	

		final= clock()-init; //final time - intial time