/*
* dbms_random.normal() RETURN NUMBER;
*
* Returns random numbers in a standard normal distribution
*/
Datum
dbms_random_normal(PG_FUNCTION_ARGS)
{
float8 result;
/* need random value from (0..1) */
result = ltqnorm(((double) rand() + 1) / ((double) RAND_MAX + 2));
PG_RETURN_FLOAT8(result);
}
ssize_t MeterRandom::read(std::vector<Reading> &rds, size_t n) {
if(rds.size() < 1) return -1;
double step = ltqnorm((float) rand() / RAND_MAX);
double newval = _last + step;
/* check boundaries */
_last += (newval > _max || newval < _min) ? -step : step;
rds[0].value(_last);
rds[0].time();
rds[0].identifier(new NilIdentifier());
return 1;
}
void randomvals_int (t_randomvals *x, t_atom_long value)
{
t_rand_gen *gen = &x->gen;
double *means = x->means;
double *devs = x->devs;
double *weights = x->weights;
double *lo_bounds = x->lo_bounds;
double *hi_bounds = x->hi_bounds;
double randval, mean, dev, lo_bound, hi_bound;
long i;
long num_params = x->num_params;
if (value >= 2)
{
// Summed windowed gaussians random distribution
// Choose a mean and dev pair based on weighting
randval = rand_double_n(gen, weights[num_params - 1]);
for (i = 0; i < num_params - 1; i++)
if (randval < weights[i])
break;
// Generate a windowed gaussian number (between 0 and 1) using a fast implementation
mean = means[i];
dev = devs[i];
lo_bound = lo_bounds[i];
hi_bound = hi_bounds[i];
randval = ltqnorm(0.5 + 0.5 * rand_double_range(gen, lo_bound, hi_bound)) * dev + mean;
if (randval > 1.)
randval = 1.;
if (randval < 0.)
randval = 0.;
}
else
{
// Generate a flat distribution random number between 0 and 1
randval = rand_double(gen);
}
outlet_float(x->the_outlet, randval);
}
void randomvals_perform64 (t_randomvals *x, t_object *dsp64, double **ins, long numins, double **outs, long numouts, long vec_size, long flags, void *userparam)
{
// Set pointers
double *in = ins[0];
double *out = outs[0];
t_rand_gen *gen = &x->gen;
double *means = x->means;
double *devs = x->devs;
double *weights = x->weights;
double *lo_bounds = x->lo_bounds;
double *hi_bounds = x->hi_bounds;
double randval, mean, dev, lo_bound, hi_bound;
long test, i;
long num_params = x->num_params;
while (vec_size--)
{
test = *in++;
if (test >= 1)
{
if (test >= 2)
{
// Summed windowed gaussians random distribution
// Choose a mean and dev pair based on weighting
randval = rand_double_n(gen, weights[num_params - 1]);
for (i = 0; i < num_params - 1; i++)
if (randval < weights[i])
break;
// Generate a windowed gaussian number (between 0 and 1) using a fast implementation
mean = means[i];
dev = devs[i];
lo_bound = lo_bounds[i];
hi_bound = hi_bounds[i];
randval = ltqnorm(0.5 + 0.5 * rand_double_range(gen, lo_bound, hi_bound)) * dev + mean;
if (randval > 1.)
randval = 1.;
if (randval < 0.)
randval = 0.;
}
else
{
// Generate a flat distribution random number between 0 and 1
randval = rand_double(gen);
}
}
else
{
// Output zeros
randval = 0;
}
*out++ = randval;
}
}
t_int *randomvals_perform (t_int *w)
{
// Set pointers
float *in = (float *) w[1];
float *out = (float *) w[2];
long vec_size = w[3];
t_randomvals *x = (t_randomvals *) w[4];
t_rand_gen *gen = &x->gen;
double *means = x->means;
double *devs = x->devs;
double *weights = x->weights;
double *lo_bounds = x->lo_bounds;
double *hi_bounds = x->hi_bounds;
double randval, mean, dev, lo_bound, hi_bound;
long test, i;
long num_params = x->num_params;
while (vec_size--)
{
test = *in++;
if (test >= 1)
{
if (test >= 2)
{
// Summed windowed gaussians random distribution
// Choose a mean and dev pair based on weighting
randval = rand_double_n(gen, weights[num_params - 1]);
for (i = 0; i < num_params - 1; i++)
if (randval < weights[i])
break;
// Generate a windowed gaussian number (between 0 and 1) using a fast implementation
mean = means[i];
dev = devs[i];
lo_bound = lo_bounds[i];
hi_bound = hi_bounds[i];
randval = ltqnorm(0.5 + 0.5 * rand_double_range(gen, lo_bound, hi_bound)) * dev + mean;
if (randval > 1.)
randval = 1.;
if (randval < 0.)
randval = 0.;
}
else
{
// Generate a flat distribution random number between 0 and 1
randval = rand_double(gen);
}
}
else
{
// Output zeros
randval = 0;
}
*out++ = randval;
}
return w + 5;
}
// Inverse of the error function erfc().
nr_double_t fspecial::erfcinv (nr_double_t x) {
return -ltqnorm (x / 2.0) / M_SQRT2;
}
vector<double> Plink::calcMantelHaenszel_2x2xK(Perm & perm, bool original)
{
// Should we perform BD test (K>1)
if (nk<2) par::breslowday = false;
ofstream MHOUT;
if ( original )
{
//////////////////////////////////
// Any individual not assigned to a cluster, making missing
// phenotype (only need to do this once, for original)
vector<Individual*>::iterator person = sample.begin();
while ( person != sample.end() )
{
if ( (*person)->sol < 0 )
(*person)->missing = true;
person++;
}
string f = par::output_file_name + ".cmh";
MHOUT.open(f.c_str(),ios::out);
MHOUT << setw(4) << "CHR" << " "
<< setw(par::pp_maxsnp) << "SNP" << " "
<< setw(10) << "BP" << " "
<< setw(4) << "A1" << " "
<< setw(8) << "MAF" << " "
<< setw(4) << "A2" << " "
<< setw(10) << "CHISQ" << " "
<< setw(10) << "P" << " "
<< setw(10) << "OR" << " "
<< setw(10) << "SE" << " "
<< setw(10) << string("L"+dbl2str(par::ci_level*100)) << " "
<< setw(10) << string("U"+dbl2str(par::ci_level*100)) << " ";
if (par::breslowday)
MHOUT << setw(10) << "CHISQ_BD" << " "
<< setw(10) << "P_BD" << " ";
MHOUT << "\n";
MHOUT.precision(4);
printLOG("Cochran-Mantel-Haenszel 2x2xK test, K = " + int2str( nk) + "\n");
if (par::breslowday)
printLOG("Performing Breslow-Day test of homogeneous odds ratios\n");
printLOG("Writing results to [ " + f + " ]\n");
// Warnings,
if (par::breslowday && nk>10)
printLOG("** Warning ** Breslow-Day statistics require large N per cluster ** \n");
}
double zt = ltqnorm( 1 - (1 - par::ci_level) / 2 ) ;
// Cochran-Mantel-Haenszel 2x2xK test
vector<double> results(nl_all);
vector<CSNP*>::iterator s = SNP.begin();
int l=0;
while ( s != SNP.end() )
{
// Skip possibly
if (par::adaptive_perm && !perm.snp_test[l])
{
s++;
l++;
continue;
}
// Disease X allele X strata
// Calculate mean of 11 cell for each strata
vector<double> mean_11(nk,0);
vector<double> var_11(nk,0);
// Calculate statistic
vector<double> n_11(nk,0);
vector<double> n_12(nk,0);
vector<double> n_21(nk,0);
vector<double> n_22(nk,0);
// Disease marginals
vector<double> n_1X(nk,0); // disease
vector<double> n_2X(nk,0); // no disease
vector<double> n_X1(nk,0); // F allele
vector<double> n_X2(nk,0); // T allele
vector<double> n_TT(nk,0); // Total allele count
/////////////////////////
// Autosomal or haploid?
bool X=false, haploid=false;
if (par::chr_sex[locus[l]->chr]) X=true;
else if (par::chr_haploid[locus[l]->chr]) haploid=true;
////////////////////////
// Consider each person
vector<bool>::iterator i1 = (*s)->one.begin();
vector<bool>::iterator i2 = (*s)->two.begin();
vector<Individual*>::iterator gperson = sample.begin();
while ( gperson != sample.end() )
{
Individual * pperson = (*gperson)->pperson;
bool s1 = *i1;
bool s2 = *i2;
// Affected individuals
if ( pperson->aff && !pperson->missing )
{
// Haploid?
if ( haploid || ( X && (*gperson)->sex ) )
{
// Allelic marginal
if ( ! s1 )
{
// FF hom
n_11[ pperson->sol ] ++ ;
n_X1[ pperson->sol ] ++ ;
}
else
{
if ( ! s2 ) // FT
{
gperson++;
i1++;
i2++;
continue; // skip missing genotypes
}
else // TT
{
n_12[ pperson->sol ] ++ ;
n_X2[ pperson->sol ] ++ ;
}
}
// Disease marginal
n_1X[ pperson->sol ] ++;
n_TT[ pperson->sol ] ++;
}
else // autosomal
{
// Allelic marginal
if ( ! s1 )
{
if ( ! s2 ) // FF hom
{
n_11[ pperson->sol ] +=2 ;
n_X1[ pperson->sol ] +=2 ;
}
else
{
n_11[ pperson->sol ]++ ; // FT het
n_12[ pperson->sol ]++ ;
n_X1[ pperson->sol ]++ ;
n_X2[ pperson->sol ]++ ;
}
}
else
{
if ( ! s2 ) // FT
{
gperson++;
i1++;
i2++;
continue; // skip missing genotypes
}
else // TT
{
n_12[ pperson->sol ] +=2 ;
n_X2[ pperson->sol ] +=2 ;
}
}
// Disease marginal
n_1X[ pperson->sol ] += 2;
n_TT[ pperson->sol ] += 2;
} // end autosomal
}
else if ( ! pperson->missing ) // Unaffecteds
{
// Haploid?
if ( haploid || ( X && (*gperson)->sex ) )
{
// Allelic marginal
if ( ! s1 )
{
// FF hom
n_21[ pperson->sol ] ++ ;
n_X1[ pperson->sol ] ++ ;
}
else
{
if ( ! s2 ) // FT
{
gperson++;
i1++;
i2++;
continue; // skip missing genotypes
}
else // TT
{
n_22[ pperson->sol ] ++ ;
n_X2[ pperson->sol ] ++ ;
}
}
// Disease marginal
n_2X[ pperson->sol ] ++;
n_TT[ pperson->sol ] ++;
}
else // autosomal
{
// Allelic marginal
if ( ! s1 )
{
if ( ! s2 ) // FF
{
n_X1[ pperson->sol ] +=2 ;
n_21[ pperson->sol ] +=2 ;
}
else
{
n_X1[ pperson->sol ] ++ ;
n_X2[ pperson->sol ] ++ ;
n_21[ pperson->sol ] ++ ;
n_22[ pperson->sol ] ++ ;
}
}
else
{
if ( ! s2 ) // FT
{
gperson++;
i1++;
i2++;
continue; // skip missing genotypes
}
else // TT
{
n_X2[ pperson->sol ] +=2 ;
n_22[ pperson->sol ] +=2 ;
}
}
// disease marginal
n_2X[ pperson->sol ] += 2;
n_TT[ pperson->sol ] += 2;
} // end autosomal
} // end unaffected
gperson++;
i1++;
i2++;
} // count next individual
// Finished iterating over individuals: cluster needs at least 2
// nonmissing individuals
vector<bool> validK(nk,false);
for (int k=0; k<nk; k++)
if (n_TT[k]>=2) validK[k]=true;
for (int k=0; k<nk; k++)
{
if (validK[k])
{
mean_11[k] = ( n_X1[k] * n_1X[k] ) / n_TT[k] ;
var_11[k] = ( n_X1[k] * n_X2[k] * n_1X[k] * n_2X[k] )
/ ( n_TT[k]*n_TT[k]*(n_TT[k]-1) );
// cout << k << " "
// << n_11[k] << " "
// << n_12[k] << " "
// << n_21[k] << " "
// << n_22[k] << "\n";
}
}
double CMH = 0;
double denom = 0;
for (int k=0; k<nk; k++)
{
if (validK[k])
{
CMH += n_11[k] - mean_11[k];
denom += var_11[k];
}
}
CMH *= CMH;
CMH /= denom;
// MH Odds ratio & CI
double R = 0;
double S = 0;
vector<double> r2(nk);
vector<double> s2(nk);
for (int k=0; k<nk; k++)
{
if (validK[k])
{
r2[k] = (n_11[k]*n_22[k]) / n_TT[k];
s2[k] = (n_12[k]*n_21[k]) / n_TT[k];
R += r2[k];
S += s2[k];
}
}
double OR = R / S ;
double v1 = 0, v2 = 0, v3 = 0;
for (int k=0; k<nk; k++)
{
if (validK[k])
{
v1 += (1/n_TT[k]) * ( n_11[k] + n_22[k] ) * r2[k] ;
v2 += (1/n_TT[k]) * ( n_12[k] + n_21[k] ) * s2[k] ;
v3 += (1/n_TT[k]) * ( ( n_11[k] + n_22[k] ) * s2[k]
+ ( n_12[k] + n_21[k] ) * r2[k] );
}
}
double SE = ( 1/(2*R*R) ) * v1
+ (1/(2*S*S)) * v2
+ (1/(2*R*S)) * v3 ;
SE = sqrt(SE);
double OR_lower = exp( log(OR) - zt * SE );
double OR_upper = exp( log(OR) + zt * SE );
if ( original )
{
double pvalue = chiprobP(CMH,1);
// Skip?, if filtering p-values
if ( par::pfilter && ( pvalue > par::pfvalue || pvalue < 0 ) )
goto skip_p_cmh;
MHOUT << setw(4) << locus[l]->chr << " "
<< setw(par::pp_maxsnp) << locus[l]->name << " "
<< setw(10) << locus[l]->bp << " "
<< setw(4) << locus[l]->allele1 << " "
<< setw(8) << locus[l]->freq << " "
<< setw(4) << locus[l]->allele2 << " ";
if (realnum(CMH))
MHOUT << setw(10) << CMH << " "
<< setw(10) << chiprobP(CMH,1) << " ";
else
MHOUT << setw(10) << "NA" << " "
<< setw(10) << "NA" << " ";
if (realnum(OR))
MHOUT << setw(10) << OR << " ";
else
MHOUT << setw(10) << "NA" << " ";
if (realnum(SE))
MHOUT << setw(10) << SE << " ";
else
MHOUT << setw(10) << "NA" << " ";
if (realnum(OR_lower))
MHOUT << setw(10) << OR_lower << " ";
else
MHOUT << setw(10) << "NA" << " ";
if (realnum(OR_upper))
MHOUT << setw(10) << OR_upper << " ";
else
MHOUT << setw(10) << "NA" << " ";
// Optional Breslow-Day test of homogeneity of odds ratios
if (par::breslowday)
{
double amax;
double bb;
double determ;
double as_plus;
double as_minus;
double Astar;
double Bstar;
double Cstar;
double Dstar;
double Var;
double BDX2 = 0;
int df = 0;
for (int k=0; k<nk; k++)
{
if (validK[k])
{
df++;
amax = (n_1X[k] < n_X1[k]) ? n_1X[k] : n_X1[k];
bb = n_2X[k] + n_1X[k] * OR - n_X1[k] * (1-OR);
determ = sqrt(bb*bb + 4*(1-OR) * OR * n_1X[k] * n_X1[k]);
as_plus = ( -bb + determ ) / ( 2 - 2 * OR );
as_minus = ( -bb - determ ) / ( 2 - 2 * OR );
Astar = as_minus <= amax && as_minus >= 0 ? as_minus : as_plus ;
Bstar = n_1X[k] - Astar;
Cstar = n_X1[k] - Astar;
Dstar = n_2X[k] - n_X1[k] + Astar;
Var = 1/(1/Astar + 1/Bstar + 1/Cstar + 1/Dstar);
BDX2 += ( (n_11[k] - Astar) * ( n_11[k] - Astar ) ) / Var ;
}
}
double BDp = chiprobP( BDX2 , df-1 );
if ( BDp > -1 )
MHOUT << setw(10) << BDX2 << " "
<< setw(10) << BDp << " ";
else
MHOUT << setw(10) << "NA" << " "
<< setw(10) << "NA" << " ";
}
MHOUT << "\n";
}
skip_p_cmh:
// Store for permutation procedure, based 2x2xK CMH result
results[l] = CMH;
// Next SNP
s++;
l++;
}
if (original)
MHOUT.close();
return results;
}