/* shift peak locations */
    sum = 0.0;
    for (j=0; j<geno_size; j++)
	{
      shift[j]=movrand()-0.5;
      sum += shift[j]*shift[j];
     }
    if(sum>0.0)
      sum = vlength/sqrt(sum);
    else                           /* only in case of rounding errors */
      sum = 0.0;
    sum2=0.0;
    for (j=0; j<geno_size; j++)
	{
      shift[j]=sum*(1.0-lambda)*shift[j]+lambda*prev_movement[i][j];
      sum2 += shift[j]*shift[j];
    }
    if(sum2>0.0)
      sum2 = vlength/sqrt(sum2);
    else                           /* only in case of rounding errors */
      sum2 = 0.0;
    for(j=0; j<geno_size; j++)
	{
      shift[j]*=sum2;
      prev_movement[i][j]= shift[j];
      if ((peak[i][j]+prev_movement[i][j]) < mincoordinate)
	  {
        peak[i][j] = 2.0*mincoordinate-peak[i][j]-prev_movement[i][j];
        prev_movement[i][j]*=-1.0;
      }
      else if ((peak[i][j]+prev_movement[i][j]) > maxcoordinate)
	  {
        peak[i][j]= 2.0*maxcoordinate-peak[i][j]-prev_movement[i][j];
        prev_movement[i][j]*=-1.0;
      }
      else
        peak[i][j] += prev_movement[i][j];
     }
    /* change peak width */
    j = geno_size;
    offset = movnrand()*width_severity;
    if ((peak[i][j]+offset) < minwidth)
      peak[i][j] = 2.0*minwidth-peak[i][j]-offset;
    else if ((peak[i][j]+offset) > maxwidth)
      peak[i][j]= 2.0*maxwidth-peak[i][j]-offset;
    else
      peak[i][j] += offset;
   /* change peak height */
    j++;
    offset = height_severity*movnrand();
    if ((peak[i][j]+offset) < minheight)
      peak[i][j] = 2.0*minheight-peak[i][j]-offset;
    else if ((peak[i][j]+offset) > maxheight)
      peak[i][j]= 2.0*maxheight-peak[i][j]-offset;
    else
      peak[i][j] += offset;
//printf("\n peak height %f", peak[i][j]);
  }

  //if(calculate_average_error)
  // Maximum peak value (global_max)
	{
    global_max = -100000.0;
    for (i=0;i<number_of_peaks; i++)
	{
      for (j=0; j<geno_size; j++)
        coordinates[j]=peak[i][j];
      dummy = dummy_eval(coordinates);
      if (dummy>global_max)
	  {
        global_max = dummy;
        maximum_peak = i;
      }
    }
	}

  recent_change = 1;
 //printf("\n eval %.0f Peaks have moved", eval_f_tot[0]);
 // printf("\n max peak %f at ", global_max);
 // for (j=0;j<geno_size;j++) printf(" %f",peak[maximum_peak][j]);

}

//================================================================= DISPLAY_PEAKS
void display_peaks()
{
  int i,j;
  printf("\n Height Width  Position");
	for (i=0; i< number_of_peaks; i++)
	{
		if(i==maximum_peak) printf("\n*"); else printf("\n ");
		printf(" %3.2f  %3.2f   ",peak[i][geno_size+1],peak[i][geno_size]);
		for (j=0; j< geno_size; j++)
		{
			printf(" %3.2f",peak[i][j]);
		}
	}
}

//=========================================================== DUMMY_EVAL
/* dummy evaluation function allows to evaluate without being counted */
double dummy_eval (double *gen)
{
  int i;
  double maximum = -100000.0, dummy;

  for(i=0; i<number_of_peaks; i++)
    {
    dummy = peak_function(gen, i);
    if (dummy > maximum)
      maximum = dummy;
    }

  if (use_basis_function) {

    dummy = basis_function(gen);
    /* If value of basis function is higher return it */
    if (maximum < dummy)
      maximum = dummy;
  }
  return(maximum);
}


//================================================================= EVAL_MOVPEAKS
/* evaluation function */
double eval_movpeaks (double *gen)
{
  int evals;
  double f;

	int i;
  double maximum = -100000.0, dummy;

  evals=eval_f_tot[0]; // for Tribes
  if ((change_frequency > 0)&&(evals%change_frequency==0) && recent_change==0)
  {
   change_peaks();// => recent_change=1
  }

  for(i=0; i<number_of_peaks; i++)
    {
    dummy = peak_function(gen, i);
    if (dummy > maximum)
      maximum = dummy;
    }

  if (use_basis_function)
  {
    dummy = basis_function(gen);
    /* If value of basis function is higher return it */
    if (maximum < dummy)
      maximum = dummy;
  }
 /*
    if (calculate_average_error)
	{
    avg_error+=global_max - maximum;
	}
*/

  /*if (calculate_offline_performance)
  {
    if(recent_change||(maximum > current_maximum))
	{
      current_error = global_max - maximum;

     // if (calculate_right_peak)
	      //current_peak_calc(gen);
     // current_maximum = maximum;
     // recent_change = 0;
    }
    //offline_performance += current_maximum;
    offline_error+= current_error;
  }
*/
  //evals ++;     /* increase the number of evaluations by one */
  f=global_max-maximum; // So that optimisation is minimisation
						// Notice that maximum may be <0

  return(f);
}

//================================================================= INIT_PEAKS
/* initialize all variables at the beginning of the program */

void init_peaks ()
{
  int i,j;
  double dummy;


  shift = (double *) calloc(geno_size, sizeof(double));
  coordinates = (double *) calloc(geno_size, sizeof(double));
//	covered_peaks = (int *) calloc(number_of_peaks, sizeof(int));
  peak = (double **) calloc(number_of_peaks, sizeof(double*));
  prev_movement = (double **) calloc(number_of_peaks, sizeof(double*));
  for (i=0; i< number_of_peaks; i++)
  {
    peak[i]= (double *) calloc(geno_size+2, sizeof(double));
    prev_movement[i] = (double *) calloc(geno_size, sizeof(double));
  }

  for (i=0; i< number_of_peaks; i++)
    for (j=0; j< geno_size; j++)
	{
      //peak[i][j] = 100.0*movrand();
		peak[i][j] =mincoordinate+ (maxcoordinate-mincoordinate)*movrand();
      prev_movement[i][j] = movrand()-0.5;
    }
  if (standardheight <= 0.0)
    for (i=0; i< number_of_peaks; i++)
      peak[i][geno_size+1]= (maxheight-minheight)*movrand()+minheight;
  else
    for (i=0; i< number_of_peaks; i++)
      peak[i][geno_size+1]= standardheight;
  if (standardwidth <= 0.0)
    for (i=0; i< number_of_peaks; i++)
      peak[i][geno_size]= (maxwidth-minwidth)*movrand()+minwidth;
  else
    for (i=0; i< number_of_peaks; i++)
      peak[i][geno_size]= standardwidth;

     // if(calculate_average_error)
	  {
		global_max = -100000.0;
		for (i=0;i<number_of_peaks; i++)
		{
			for (j=0; j<geno_size; j++)
				coordinates[j]=peak[i][j];
			dummy = dummy_eval(coordinates);
			 if (dummy>global_max)
			 { maximum_peak=i;
					global_max = dummy;
			 }
		}
	}

//printf("\n max peak %f , number %i, at \n", global_max,maximum_peak+1);
//for (j=0;j<geno_size;j++) printf(" %f",peak[maximum_peak][j]);
display_peaks();

}



double movrand() { return alea_float(0,1);} // Compatibility with Tribes
double movnrand() { return alea_normal(0,1);}