void GUE(int n, double **h, double sigma, long *iseed, enum trace traceless) {
/* hermitean Gaussian random matrix. */
/* P(H) \propto \exp{-Tr(H^2)/2/sigma^2}. */
/* <|H_ij|^2>=sigma^2 */
/* output in h[0...n-1][0..2(n-1)+1]. */
int i,j;
double tmp;
/* diagonal - real */
tmp=sigma/sqrt(2);
for(i=0;i<n;i++) {
h[i][2*i]=gasdev(iseed)*sigma;
h[i][2*i+1]=0;
}
/* upper triangle - complex */
for(j=1;j<n;j++) for(i=0;i<j;i++) {
h[i][2*j]=gasdev(iseed)*tmp;
h[i][2*j+1]=gasdev(iseed)*tmp;
}
/* fill dependent elements - lower triangle */
for(i=1;i<n;i++) for(j=0;j<i;j++) {
h[i][2*j]=h[j][2*i];
h[i][2*j+1]=-h[j][2*i+1];
}
if (traceless==TRACELESS) { /* substract TrH /n */
tmp=0;
for(i=0;i<n;i++) tmp+=h[i][2*i];
tmp=tmp/n;
for(i=0;i<n;i++) h[i][2*i]-=tmp;
}
return ;
}
void add_noise(struct uvf_header **header, struct uvf_sample **samples,
int n_archivos, long *seed) {
int arch, i, k, nsamp, nchan;
float sum =0;
//float target_Chi2 = 31291. ;
double sigma;
double visnoise;
float scale_factor;
double sum_VR = 0, sum_VI = 0, sum_noise = 0, noise;
for (arch = 0; arch < n_archivos; arch++) {
nsamp = header[arch]->nsamp;
nchan = header[arch]->nchan;
for (i = 0; i < nsamp; i++) { /* Loop through samples */
for (k = 0; k < nchan; k++) { /* Loop through channels */
if (samples[arch][i].rdata[3*k+2] != 0) {
visnoise = sqrt(1/samples[arch][i].rdata[3*k+2]);
noise = gasdev(seed)*visnoise;
sum_noise += fabs(noise);
sum_VR += fabs(samples[arch][i].rdata[3*k]);
sum_VI += fabs(samples[arch][i].rdata[3*k+1]);
samples[arch][i].rdata[3*k] += gasdev(seed)*visnoise; // DEVTEST
samples[arch][i].rdata[3*k+1] += gasdev(seed)*visnoise; // DEVTEST
} /* weights */
}
}
}
printf ("suma = %g\t%g,\t noise = %g\n",
sum_VR, sum_VI, sum_noise);
}
int main(void)
{
long idum=(-51773);
int i,j;
float fctr1,fctr2,prob,t,*data1,*data2;
data1=vector(1,NPTS);
data2=vector(1,MPTS);
/* Generate two gaussian distributions of different variance */
fctr1=sqrt(VAR1);
for (i=1;i<=NPTS;i++) data1[i]=fctr1*gasdev(&idum);
fctr2=sqrt(VAR2);
for (i=1;i<=MPTS;i++)
data2[i]=NSHFT/2.0*EPS+fctr2*gasdev(&idum);
printf("\nDistribution #1 : variance = %6.2f\n",VAR1);
printf("Distribution #2 : variance = %6.2f\n\n",VAR2);
printf("%7s %8s %16s\n","shift","t","probability");
for (i=1;i<=NSHFT+1;i++) {
tutest(data1,NPTS,data2,MPTS,&t,&prob);
printf("%6.2f %10.2f %11.2f\n",(i-1)*EPS,t,prob);
for (j=1;j<=NPTS;j++) data1[j] += EPS;
}
free_vector(data2,1,MPTS);
free_vector(data1,1,NPTS);
return 0;
}
/* random number of unit sphere Gnml coefficient */
MyDouble SCF_Gnml_rand(int n, int l, int m, long *seed)
{
if (n+l+m>0)
return 1./sqrt(1.*SCF_NEFF)*sqrt(gnlm_var(n,l,m))*gasdev(seed);
else
return -1.+ 1./sqrt(1.*SCF_NEFF)*sqrt(gnlm_var(n,l,m))*gasdev(seed);
}
/// Sets the temperature of system.
///
/// Selects atom velocities randomly from a boltzmann (equilibrium)
/// distribution that corresponds to the specified temperature. This
/// random process will typically result in a small, but non zero center
/// of mass velocity and a small difference from the specified
/// temperature. For typical MD runs these small differences are
/// unimportant, However, to avoid possible confusion, we set the center
/// of mass velocity to zero and scale the velocities to exactly match
/// the input temperature.
void setTemperature(SimFlat* s, real_t temperature)
{
// set initial velocities for the distribution
printf("CnC: Inside setTemperature %f, %d\n",temperature, s->boxes->nLocalBoxes);
for (int iBox=0; iBox<s->boxes->nLocalBoxes; ++iBox)
{
for (int iOff=MAXATOMS*iBox, ii=0; ii<s->boxes->nAtoms[iBox]; ++ii, ++iOff)
{
int iType = s->atoms->iSpecies[iOff];
real_t mass = s->species[iType].mass;
real_t sigma = sqrt(kB_eV * temperature/mass);
uint64_t seed = mkSeed(s->atoms->gid[iOff], 123);
#ifndef CNCOCR_TG // Manu: gasdev not working with TG
s->atoms->p[iOff][0] = mass * sigma * gasdev(&seed);
s->atoms->p[iOff][1] = mass * sigma * gasdev(&seed);
s->atoms->p[iOff][2] = mass * sigma * gasdev(&seed);
#else
s->atoms->p[iOff][0] = mass * sigma;
s->atoms->p[iOff][1] = mass * sigma;
s->atoms->p[iOff][2] = mass * sigma;
#endif
}
}
// compute the resulting temperature
// kinetic energy = 3/2 kB * Temperature
if (temperature == 0.0) return;
real_t vZero[3] = {0., 0., 0.};
setVcm(s, vZero);
kineticEnergy(s);
real_t temp = (s->eKinetic/s->atoms->nGlobal)/kB_eV/1.5;
// scale the velocities to achieve the target temperature
real_t scaleFactor = sqrt(temperature/temp);
// real_t scaleFactor =1;
for (int iBox=0; iBox<s->boxes->nLocalBoxes; ++iBox)
{
for (int iOff=MAXATOMS*iBox, ii=0; ii<s->boxes->nAtoms[iBox]; ++ii, ++iOff)
{
s->atoms->p[iOff][0] *= scaleFactor;
s->atoms->p[iOff][1] *= scaleFactor;
s->atoms->p[iOff][2] *= scaleFactor;
}
}
kineticEnergy(s);
temp = s->eKinetic/s->atoms->nGlobal/kB_eV/1.5;
}
int main(void)
{
long idum;
unsigned long j,jtrial,n1,n2,ntrial;
float d,prob,shrink,u,v;
float *x1,*y1,*x2,*y2;
x1=vector(1,NMAX);
y1=vector(1,NMAX);
x2=vector(1,NMAX);
y2=vector(1,NMAX);
for (;;) {
printf("Input N1,N2\n");
if (scanf("%lu %lu",&n1,&n2) == EOF) break;
if (n1 > NMAX) {
printf("n1 too large.\n");
continue;
}
if (n2 > NMAX) {
printf("n2 too large.\n");
continue;
}
printf("What shrinkage?\n");
if (scanf("%f",&shrink) == EOF) break;
printf("How many trials?\n");
if (scanf("%lu",&ntrial) == EOF) break;
if (ntrial > NMAX) {
printf("Too many trials.\n");
continue;
}
idum = -287-ntrial-n1-n2;
for (jtrial=1;jtrial<=ntrial;jtrial++) {
for (j=1;j<=n1;j++) {
u=gasdev(&idum);
v=gasdev(&idum)*shrink;
x1[j]=u+v;
y1[j]=u-v;
}
for (j=1;j<=n2;j++) {
u=gasdev(&idum)*shrink;
v=gasdev(&idum);
x2[j]=u+v;
y2[j]=u-v;
}
ks2d2s(x1,y1,n1,x2,y2,n2,&d,&prob);
printf("d, prob= %12.6f %12.6f\n",d,prob);
}
}
free_vector(y2,1,NMAX);
free_vector(x2,1,NMAX);
free_vector(y1,1,NMAX);
free_vector(x1,1,NMAX);
printf("Normal completion\n");
return 0;
}
int main(void)
{
long idum=(-1);
int j;
float a,b,chi2,q,sa,sb,siga,sigb;
float *x,*y,*dx,*dy,*dz;
x=vector(1,NPT);
y=vector(1,NPT);
dx=vector(1,NPT);
dy=vector(1,NPT);
dz=vector(1,NPT);
for (j=1;j<=NPT;j++) {
dx[j]=0.1+ran1(&idum);
dy[j]=0.1+ran1(&idum);
dz[j]=0.0;
x[j]=10.0+10.0*gasdev(&idum);
y[j]=2.0*x[j]-5.0+dy[j]*gasdev(&idum);
x[j] += dx[j]*gasdev(&idum);
}
printf("Values of a,b,siga,sigb,chi2,q:\n");
printf("Fit with x and y errors gives:\n");
fitexy(x,y,NPT,dx,dy,&a,&b,&siga,&sigb,&chi2,&q);
printf("%11.6f %11.6f %11.6f %11.6f %11.6f %11.6f\n\n",
a,b,siga,sigb,chi2,q);
printf("Setting x errors to zero gives:\n");
fitexy(x,y,NPT,dz,dy,&a,&b,&siga,&sigb,&chi2,&q);
printf("%11.6f %11.6f %11.6f %11.6f %11.6f %11.6f\n",
a,b,siga,sigb,chi2,q);
printf("...to be compared with fit result:\n");
fit(x,y,NPT,dy,1,&a,&b,&siga,&sigb,&chi2,&q);
printf("%11.6f %11.6f %11.6f %11.6f %11.6f %11.6f\n\n",
a,b,siga,sigb,chi2,q);
printf("Setting y errors to zero gives:\n");
fitexy(x,y,NPT,dx,dz,&a,&b,&siga,&sigb,&chi2,&q);
printf("%11.6f %11.6f %11.6f %11.6f %11.6f %11.6f\n",
a,b,siga,sigb,chi2,q);
printf("...to be compared with fit result:\n");
fit(y,x,NPT,dx,1,&a,&b,&siga,&sigb,&chi2,&q);
sa=sqrt(siga*siga+SQR(sigb*(a/b)))/b;
sb=sigb/(b*b);
printf("%11.6f %11.6f %11.6f %11.6f %11.6f %11.6f\n",
-a/b,1.0/b,sa,sb,chi2,q);
free_vector(dz,1,NPT);
free_vector(dy,1,NPT);
free_vector(dx,1,NPT);
free_vector(y,1,NPT);
free_vector(x,1,NPT);
return 0;
}
int main(void)
{
long idum=(-1984);
int i,mwt=1;
float a,abdev,b,chi2,q,siga,sigb;
float *x,*y,*sig;
x=vector(1,NDATA);
y=vector(1,NDATA);
sig=vector(1,NDATA);
for (i=1;i<=NPT;i++) {
x[i]=0.1*i;
y[i] = -2.0*x[i]+1.0+SPREAD*gasdev(&idum);
sig[i]=SPREAD;
}
fit(x,y,NPT,sig,mwt,&a,&b,&siga,&sigb,&chi2,&q);
printf("\nAccording to routine FIT the result is:\n");
printf(" a = %8.4f uncertainty: %8.4f\n",a,siga);
printf(" b = %8.4f uncertainty: %8.4f\n",b,sigb);
printf(" chi-squared: %8.4f for %4d points\n",chi2,NPT);
printf(" goodness-of-fit: %8.4f\n",q);
printf("\nAccording to routine MEDFIT the result is:\n");
medfit(x,y,NPT,&a,&b,&abdev);
printf(" a = %8.4f\n",a);
printf(" b = %8.4f\n",b);
printf(" absolute deviation (per data point): %8.4f\n",abdev);
printf(" (note: gaussian SPREAD is %8.4f)\n",SPREAD);
free_vector(sig,1,NDATA);
free_vector(y,1,NDATA);
free_vector(x,1,NDATA);
return 0;
}
//--------------------------------------------------------
void add_watermark(double *in, int N, int coeff_start, int wm_length, int wm_key, double wm_alpha)
{
int row, col, count;
long int elem, L, M, temp, seed;
double a;
count = 0;
elem = 0;
row = 2;
col = -1;
M = coeff_start;
L = wm_length;
seed = wm_key;
a = wm_alpha;
do {
do {
row--;
col++;
elem++;
if (col < N) {
if (elem > M) {
temp = row * N + col;
in[temp] += a * fabs(in[temp]) * gasdev(&seed);
count++;
}
}
} while (row > 0);
row = 2 + col;
col = -1;
} while (count < L);
}
int main(void)
{
long idum=(-11);
int i;
float b,rf,*x,*y;
x=vector(1,NDATA);
y=vector(1,NDATA);
ndatat=NDATA;
xt=x;
yt=y;
for (i=1;i<=NDATA;i++) {
x[i]=0.1*i;
y[i] = -2.0*x[i]+1.0+SPREAD*gasdev(&idum);
}
printf("%9s %9s %12s %10s\n","b","a","ROFUNC","ABDEVT");
for (i = -5;i<=5;i++) {
b = -2.0+0.02*i;
rf=rofunc(b);
printf("%10.2f %9.2f %11.2f %10.2f\n",
b,aa,rf,abdevt);
}
free_vector(y,1,NDATA);
free_vector(x,1,NDATA);
return 0;
}
void read_watermark(double **in, int N, int coeff_start, int wm_length, double wm_alpha)
{
int row, col, count;
long int elem, L, M, seed, i;
double a;
double z;
M = coeff_start;
L = wm_length;
a = wm_alpha;
for (i = 1; i <= 1000; i++) {
seed = i;
z = 0.0;
count = 0;
elem = 0;
for (row = 0; row < N; row++)
for (col = 0; col < N; col++) {
elem++;
if (elem > M && count < L) {
z += in[row][col] * gasdev(&seed);
count++;
}
}
printf("%ld\t%f\n", i, z / L);
}
return ;
}
/* This function creates the double gaussian distruted x-values for the dopand atoms
* width1 i the distance between the 2 peaks
* width 2 is the width of a single peak.
*/
double xDistrFun2(double xcenter,double width1,double width2) {
static long idum = 0;
static long seed = 0;
static int count = 0;
static double x2=0,xavg=0;
double x,dx;
if (idum == 0) idum = -(long)(time(NULL));
if (seed == 0) seed = -(long)(time(NULL));
if (width2 >0) {
count ++;
dx = width2*gasdev(&idum);
x = xcenter+width1*((ran(&seed) > 0.5)-0.5)+dx;
xavg += x;
x2 += SQR(dx);
return x;
}
else {
printf("Statistics (%d): xavg=%g, x2dev=%g\n",count,xavg/(double)count,sqrt(x2/(double)count));
xavg = 0;
x2 = 0;
return 0;
}
}
float bingdev(float *xbin, float *ybin, unsigned int nbin, long *idnum)
{
int i;
int bin,peak,wing;
float firstdev,seconddev,fx,x;
float stddev,F;
int findbin(float x, float *xbin, unsigned int nbin);
int findpeak(float *ybin, unsigned int nbin);
/* set the gaussian parameters so that f(x) is larger than ybin */
peak=findpeak(ybin,nbin);
wing = ( (peak < nbin/2) ? nbin-1: 0 );
stddev = sqrt( 0.5*pow((xbin[wing]-xbin[peak]),2)/log(ybin[peak]/ybin[wing]) );
F = 1.25*ybin[peak]*stddev*SQRT2PI;
do {
/* First deviate - Gaussian */
firstdev = gasdev(idnum);
x = firstdev *stddev + xbin[peak];
fx = 1./(stddev*SQRT2PI) * exp( -0.5*pow(firstdev,2) );
fx *= F;
/* Second deviate between 0 and fx - reject if not under ybin */
if ( (bin = findbin(x,xbin,nbin)) > 0 ) { /*within range; proceed*/
seconddev = fx * ran1(idnum);
}
} while ((seconddev > ybin[bin]) || (bin<0));
return x;
}
int main(void)
{
long idum=(-911);
int i,j,mfit=MA,*ia;
float chisq,*beta,*x,*y,*sig,**covar,**alpha;
static float a[MA+1]=
{0.0,5.0,2.0,3.0,2.0,5.0,3.0};
static float gues[MA+1]=
{0.0,4.9,2.1,2.9,2.1,4.9,3.1};
ia=ivector(1,MA);
beta=vector(1,MA);
x=vector(1,NPT);
y=vector(1,NPT);
sig=vector(1,NPT);
covar=matrix(1,MA,1,MA);
alpha=matrix(1,MA,1,MA);
/* First try sum of two gaussians */
for (i=1;i<=NPT;i++) {
x[i]=0.1*i;
y[i]=0.0;
y[i] += a[1]*exp(-SQR((x[i]-a[2])/a[3]));
y[i] += a[4]*exp(-SQR((x[i]-a[5])/a[6]));
y[i] *= (1.0+SPREAD*gasdev(&idum));
sig[i]=SPREAD*y[i];
}
for (i=1;i<=mfit;i++) ia[i]=1;
for (i=1;i<=mfit;i++) a[i]=gues[i];
mrqcof(x,y,sig,NPT,a,ia,MA,alpha,beta,&chisq,fgauss);
printf("\nmatrix alpha\n");
for (i=1;i<=MA;i++) {
for (j=1;j<=MA;j++) printf("%12.4f",alpha[i][j]);
printf("\n");
}
printf("vector beta\n");
for (i=1;i<=MA;i++) printf("%12.4f",beta[i]);
printf("\nchi-squared: %12.4f\n\n",chisq);
/* Next fix one line and improve the other */
mfit=3;
for (i=1;i<=mfit;i++) ia[i]=0;
for (i=1;i<=MA;i++) a[i]=gues[i];
mrqcof(x,y,sig,NPT,a,ia,MA,alpha,beta,&chisq,fgauss);
printf("matrix alpha\n");
for (i=1;i<=mfit;i++) {
for (j=1;j<=mfit;j++) printf("%12.4f",alpha[i][j]);
printf("\n");
}
printf("vector beta\n");
for (i=1;i<=mfit;i++) printf("%12.4f",beta[i]);
printf("\nchi-squared: %12.4f\n\n",chisq);
free_matrix(alpha,1,MA,1,MA);
free_matrix(covar,1,MA,1,MA);
free_vector(sig,1,NPT);
free_vector(y,1,NPT);
free_vector(x,1,NPT);
free_vector(beta,1,MA);
free_ivector(ia,1,MA);
return 0;
}
static double GD (double mean, double sdev)
/* ------------------------------------------------------------------------- *
* Return normally distributed random deviate with specified mean and
* standard deviation.
* ------------------------------------------------------------------------- */
{
return (mean + sdev * (gasdev (&iseed)));
}
double get(int bias, int multiple, Distribution_Type type, int *idum)
{
double ret = 0;
if(type == Distribution_Type_Gaussian) ret = gasdev(idum);
else if(type == Distribution_Type_Uniform) ret = uniform(idum);
else assert(false);
return ret * multiple + bias;
}
int main(void)
{
long idum=(-911);
int i,j,*ia;
float chisq,*a,*x,*y,*sig,**covar;
ia=ivector(1,NTERM);
a=vector(1,NTERM);
x=vector(1,NPT);
y=vector(1,NPT);
sig=vector(1,NPT);
covar=matrix(1,NTERM,1,NTERM);
for (i=1;i<=NPT;i++) {
x[i]=0.1*i;
funcs(x[i],a,NTERM);
y[i]=0.0;
for (j=1;j<=NTERM;j++) y[i] += j*a[j];
y[i] += SPREAD*gasdev(&idum);
sig[i]=SPREAD;
}
for (i=1;i<=NTERM;i++) ia[i]=1;
lfit(x,y,sig,NPT,a,ia,NTERM,covar,&chisq,funcs);
printf("\n%11s %21s\n","parameter","uncertainty");
for (i=1;i<=NTERM;i++)
printf(" a[%1d] = %8.6f %12.6f\n",
i,a[i],sqrt(covar[i][i]));
printf("chi-squared = %12f\n",chisq);
printf("full covariance matrix\n");
for (i=1;i<=NTERM;i++) {
for (j=1;j<=NTERM;j++) printf("%12f",covar[i][j]);
printf("\n");
}
printf("\npress RETURN to continue...\n");
(void) getchar();
/* Now check results of restricting fit parameters */
for (i=2;i<=NTERM;i+=2) ia[i]=0;
lfit(x,y,sig,NPT,a,ia,NTERM,covar,&chisq,funcs);
printf("\n%11s %21s\n","parameter","uncertainty");
for (i=1;i<=NTERM;i++)
printf(" a[%1d] = %8.6f %12.6f\n",
i,a[i],sqrt(covar[i][i]));
printf("chi-squared = %12f\n",chisq);
printf("full covariance matrix\n");
for (i=1;i<=NTERM;i++) {
for (j=1;j<=NTERM;j++) printf("%12f",covar[i][j]);
printf("\n");
}
printf("\n");
free_matrix(covar,1,NTERM,1,NTERM);
free_vector(sig,1,NPT);
free_vector(y,1,NPT);
free_vector(x,1,NPT);
free_vector(a,1,NTERM);
free_ivector(ia,1,NTERM);
return 0;
}
void GOE(int n, double **o, double sigma, long *iseed) {
/* real symmetric Gaussian random matrix */
/* P(H) \propto \exp{-Tr(H^2)/2sigma^2}. */
/* output in o[0..n-1][0..n-1]. */
int i,j;
double tmp;
/* upper triangle;sqrt(2) is because of lower el.*/
tmp=sigma/sqrt(2);
for(j=1;j<n;j++) for(i=0;i<j;i++) o[i][j]=gasdev(iseed)*tmp;
/* diagonal */
for(i=0;i<n;i++) o[i][i]=gasdev(iseed)*sigma;
/* fill dependent elements - lower triangle */
for(i=1;i<n;i++) for(j=0;j<i;j++) o[i][j]=o[j][i];
return ;
}
/*!
* Gaussian random number generator
*/
double gaussian(double mean,
double sigma,
long *seed)
{
double rannum;
while (fabs(rannum = gasdev(seed)) > 3) {}
return mean + sigma*rannum;
}
void make_AR1(control *c, timeseries *ts)
{
/*
set up AR1 time series. An AR spectrum models the data using a linear combination of the previous and
subsequent time steps (see Mann and Lees, 1996):
red[i] = rho[i] * y[i-1] + eps[i]
where
t[i] - t[i-1]
rho[i] = exp(--------------)
tau
and
eps ~ NV(0, vareps). To ensure Var[red] = 1, we set
2 * (t[i] - t[i-1])
vareps = 1 - exp(- -------------------).
tau
Stationarity of the generated AR(1) time series is assured by dropping
the first N generated points.
*/
int k;
double dt, sigma;
ts->red[1] = gasdev(&ts->idum);
for (k = 2; k <= ts->num_param; k++) {
dt = ts->x[k] - ts->x[k - 1];
sigma = sqrt(1.0 - exp(-2.0 * dt / ts->tau));
if (c->EQUAL_DIST_DATA == TRUE) {
ts->red[k] = exp(-dt / ts->equalrho) * ts->red[k - 1] + sigma * gasdev(&ts->idum);
} else {
ts->red[k] = exp(-dt / ts->tau) * ts->red[k - 1] + sigma * gasdev(&ts->idum);
}
}
return;
}
void main () {
long seed, s2=-13;
int i;
FILE *fp;
srand(time(NULL));
fp = fopen("../../results/randnout", "w");
for(i=0; i <1000000; ++i) {
seed = -1 * rand();
fprintf(fp, "%f \n", gasdev(&seed));
}
fclose(fp);
}
void
fake_observation(PBASIS *p,
OBSERVATION *obs)
{
static long idum=-1;
float gasdev(long *idum);
/* seed the random number generator*/
if (idum<0) {
struct timeval tp;
gettimeofday(&tp,NULL);
idum = -tp.tv_usec;
}
kbo2d(p,obs,&(obs->thetax),NULL,&(obs->thetay),NULL);
/* Add measurement noise to the positions */
obs->thetax += obs->dthetax*gasdev(&idum);
obs->thetay += obs->dthetay*gasdev(&idum);
return;
}
/* ------------------------------------------------ */
float32 gaussian_noise(float32 average, float32 sigma)
/* ------------------------------------------------ */
{
// not thread safe
static long seed = 0x101; // not for multi-threaded purpose
float g, r;
g = gasdev(&seed);
r = average + sigma * g;
return r;
}
/* n degrees of freedom zero mean and unit variance */
double chisquare(int n,long*seed)
{
int i,j;
double rand,gauss;
for(j=0,rand=0; j<n; j++) {
gauss=gasdev(seed);
rand+=gauss*gauss;
}
rand=(rand/n-1)/sqrt(2.0/n);
return rand;
}
static void add_noise(struct uvf_header *header,
struct uvf_sample *samples, long *seed) {
int i, k, nsamp, nchan;
float sum =0;
//float target_Chi2 = 31291. ;
double sigma;
double visnoise;
float scale_factor;
nsamp = header->nsamp;
nchan = header->nchan;
double sum_VR = 0, sum_VI = 0, sum_noise = 0, noise;
for (i = 0; i < nsamp; i++) { /* Loop through samples */
for (k = 0; k < nchan; k++) { /* Loop through channels */
//if (!ch_list[k])
//continue;
if (samples[i].rdata[3*k+2] != 0) {
visnoise = sqrt(1/samples[i].rdata[3*k+2]);
noise = gasdev(seed)*visnoise;
//printf ("V = %g\t%g,\t noise = %g\n",
//samples[i].rdata[3*k], samples[i].rdata[3*k+1],
//noise);
sum_noise += fabs(noise);
sum_VR += fabs(samples[i].rdata[3*k]);
sum_VI += fabs(samples[i].rdata[3*k+1]);
//sigma = visnoise * scale_factor;
//printf("%g %g %g \n",gasdev(seed),visnoise,sigma);
//printf("%g --> ",samples[i].rdata[3*k]);
samples[i].rdata[3*k] += gasdev(seed)*visnoise; // DEVTEST
//printf("%g \n ",samples[i].rdata[3*k]);
samples[i].rdata[3*k+1] += gasdev(seed)*visnoise; // DEVTEST
} /* weights */
}
}
printf ("suma = %g\t%g,\t noise = %g\n",
sum_VR, sum_VI, sum_noise);
}
/* This sets the velocity to be isotropic Gaussian.
*/
double NFW_central_velocity(double mass, double v[], double mag)
{
static long IDUM2=-455;
static double fac = -1;
double sigv,vbias=1;
int i;
if(fac<0)
fac=sqrt(4.499E-48)*pow(4*DELTA_HALO*PI*OMEGA_M*RHO_CRIT/3,1.0/6.0)*3.09E19;
sigv=fac*pow(mass,1.0/3.0)/sqrt(2.0);
for(i=0;i<3;++i)
v[i]=gasdev(&IDUM2)*sigv*VBIAS_C;
return(0);
}
/*---------------------------------*
* Function Poisson Distribution |
*---------------------------------*
| Returns the integer value corresponding to the
| probablity given by the poisson distribution.
*/
int poisso(double u) //u= Mean of poisson distribution
{
double cump=0.0, ru=0.0, p=0.0, ran1(), gasdev(double, double);
int i=1;
if(u>30.) return((int)(0.5+gasdev(u, u))); // Correction when mean > 30 ?? why?
ru=ran1();
p=exp(-u);
if(ru<p) return(0);
cump=p; // Cumulative probability function
while(ru>(cump+=(p*=u/i)))
i++;
return(i);
}
void mnormalnew (header *hd)
{ header *st=hd,*result;
double *m;
int r,c;
LONG k,n;
hd=getvalue(hd); if (error) return;
if (hd->type!=s_matrix || dimsof(hd)->r!=1 || dimsof(hd)->c!=2
|| *(m=matrixof(hd))<0 || *m>=INT_MAX
|| *(m+1)<0 || *(m+1)>INT_MAX)
wrong_arg_in("normal");
r=(int)*m;
c=(int)*(m+1);
result=new_matrix(r,c,""); if (error) return;
m=matrixof(result);
n=(LONG)c*r;
for (k=0; k<n; k++) *m++=gasdev();
moveresult(st,result);
}
int main(void)
{
long idum=(-911);
int i;
float chisq,*x,*y,*sig,*a,*w,**cvm,**u,**v;
x=vector(1,NPT);
y=vector(1,NPT);
sig=vector(1,NPT);
a=vector(1,NPOL);
w=vector(1,NPOL);
cvm=matrix(1,NPOL,1,NPOL);
u=matrix(1,NPT,1,NPOL);
v=matrix(1,NPOL,1,NPOL);
for (i=1;i<=NPT;i++) {
x[i]=0.02*i;
y[i]=1.0+x[i]*(2.0+x[i]*(3.0+x[i]*(4.0+x[i]*5.0)));
y[i] *= (1.0+SPREAD*gasdev(&idum));
sig[i]=y[i]*SPREAD;
}
svdfit(x,y,sig,NPT,a,NPOL,u,v,w,&chisq,fpoly);
svdvar(v,NPOL,w,cvm);
printf("\npolynomial fit:\n\n");
for (i=1;i<=NPOL;i++)
printf("%12.6f %s %10.6f\n",a[i]," +-",sqrt(cvm[i][i]));
printf("\nChi-squared %12.6f\n",chisq);
svdfit(x,y,sig,NPT,a,NPOL,u,v,w,&chisq,fleg);
svdvar(v,NPOL,w,cvm);
printf("\nLegendre polynomial fit:\n\n");
for (i=1;i<=NPOL;i++)
printf("%12.6f %s %10.6f\n",a[i]," +-",sqrt(cvm[i][i]));
printf("\nChi-squared %12.6f\n",chisq);
free_matrix(v,1,NPOL,1,NPOL);
free_matrix(u,1,NPT,1,NPOL);
free_matrix(cvm,1,NPOL,1,NPOL);
free_vector(w,1,NPOL);
free_vector(a,1,NPOL);
free_vector(sig,1,NPT);
free_vector(y,1,NPT);
free_vector(x,1,NPT);
return 0;
}
// ----------------------------------------------------------------
int main(
int argc,
char ** argv)
{
opts_t opts;
int i;
set_defaults(&opts);
if (!parse_command_line(argc, argv, &opts))
usage(argv[0]);
if (opts.do_seed)
sran32b(opts.seed0, opts.seed1);
for (i = 0; i < opts.num_samples; i++) {
float rand = opts.mean + opts.stddev * gasdev();
printf("%11.7f\n", rand);
}
return 0;
}
