int main(void) {
double vol[NEXP]; /* calculated values of SE */
gsl_rng *r;
double mean, sd;
int j, n;
unsigned long seed = 1UL;
long p = pow(2, 19.);
/* allocate random number generator */
r = gsl_rng_alloc(gsl_rng_taus2);
/* seed the random number generator */
gsl_rng_set(r, seed);
for (n = 1; n < 10; n++)
{
for (j = 0; j < NEXP; j++) {
/* calculate pi using Monte Carlo algorithm */
vol[j] = mc_se(p, n, r);
}
mean = gsl_stats_mean(vol, 1, NEXP);
sd = gsl_stats_sd_m(vol, 1, NEXP, mean);
printf("%15ld %15d %14.8f %14.8f\n", p, n, mean, sd);
}
gsl_rng_free(r);
return(0);
}
void shapeAlign::scaleMatrixZscore(gsl_matrix *M){
for (size_t i = 0; i < M->size1; i++){
gsl_vector_view row = gsl_matrix_row(M,i);
double mu = gsl_stats_mean(row.vector.data, row.vector.stride, row.vector.size);
double sigma = gsl_stats_sd_m(row.vector.data, row.vector.stride, row.vector.size, mu);
gsl_vector_add_constant(&row.vector,-mu);
gsl_vector_scale(&row.vector,1.0/sigma);
}
return;
}
/* ------------------------------- ut_trunc_sigma_unknown ------------------ */
void ut_trunc_sigma_unknown_fast_sorted(double** values, int * nitems, double sigcut){
/* trunc the data set, removing any value outside +/- sigcut sigma
if sigcut<0, does noting .
it works grossly, removing each time all what is outside the window,
which is not accurate
Beware : sigma is computed from the distribution itself.
Points far away will push the sigma towards greater values.
values : pointer to array of values - modified
nitems : number of values -> modified
sigcut : if <0, does nothing
Beware : the number of remaining items might be 0 !
*/
int ok=0;
if (sigcut<0)
return;
/* qsort(*values,*nitems,sizeof(double),ascending); */
while (!ok && *nitems>1) {
double mean,sigma,valinf,valsup;
int nitems_old = *nitems;
mean = ut_mean((*values),*nitems);
sigma = gsl_stats_sd_m(*values,1,*nitems,mean);
valinf = mean-sigma*sigcut;
valsup = mean + sigma*sigcut;
while ((*values)[0] < valinf && *nitems>1) {
(*nitems)--;
(*values)++;
}
while ((*values)[*nitems-1] > valsup && *nitems>1) {
(*nitems)--;
}
if (nitems_old == (*nitems))
ok=1;
}
}
int ZeroOutliersOne (double *buf, int len, double alpha) {
/*
Replace outliers in the input buffer with zeros using the Grubbs
test (at the significance level alpha). The buffer is
overwritten. Return the number of outliers found.
*/
int noutliers = 0, idx, n, outlier = 1;
double meanval, maxval, sdval, tn, critval, v, *tmp;
tmp = (double *) malloc (len*sizeof (double));
while (outlier) {
n = 0;
for (idx=0; idx<len; idx++)
if ((v=*(buf+idx)))
*(tmp+n++) = v;
if (n>2) {
meanval = gsl_stats_mean (tmp, 1, n);
maxval = meanval;
for (idx=0; idx<n; idx++) {
v = *(tmp+idx);
if (fabs(v-meanval) > fabs(maxval-meanval))
maxval = v;
}
sdval = gsl_stats_sd_m (tmp, 1, n, meanval);
tn = fabs ((maxval-meanval)/sdval);
critval = zcritical (alpha, n);
if (tn>critval) {
for (idx=0; idx<len; idx++)
if (*(buf+idx) == maxval) {
*(buf+idx) = 0;
noutliers++;
}
} else
outlier = 0;
} else
outlier = 0;
}
free (tmp);
return noutliers;
}
/* ------------------------------- ut_trunc_sigma_unknown ------------------ */
void ut_trunc_sigma_unknown(double** values, int * nitems, double sigcut){
/* trunc the data set, removing any value outside +/- sigcut sigma
if sigcut<0, does noting .
it works iteratively by removing too far away values. => slow if
the sigcut is too low !
Beware : sigma is computed from the distribution itself.
Points far away will push the sigma towards greater values.
values : pointer to array of values - modified
nitems : number of values -> modified
sigcut : if <0, does nothing
Beware : the number of remaining items might be 0 !
*/
int ok=0;
if (sigcut<0)
return;
qsort(*values,*nitems,sizeof(double),ascending);
while (!ok && *nitems>1) {
double mean,sigma,valinf,valsup;
mean = ut_mean((*values),*nitems);
sigma = gsl_stats_sd_m(*values,1,*nitems,mean);
valinf = (mean-(*values)[0])/sigma;
valsup = ((*values)[*nitems-1]-mean)/sigma;
if (valsup>sigcut && valsup>=valinf) {
(*nitems)--;
} else if (valinf>sigcut && valinf>=valsup) {
(*nitems)--;
(*values)++;
} else {
ok=1;
}
}
}
void streamRtsFile(xmlTextReaderPtr reader)
{
if (reader == NULL) {
fprintf(stderr, "Unable to access the file.\n");
exit(EXIT_FAILURE);
}
int ret;
if (verbose) {
printf("=== Analyzing ===\n");
}
ret = xmlTextReaderRead(reader);
while (ret == 1 && cont > 0) {
processNode(reader);
ret = xmlTextReaderRead(reader);
}
if (ret != 0 && cont > 0) {
printf("Failed to parse.\n");
return;
}
printf("=== FU result ===\n");
double mean = gsl_stats_mean(fuArray, 1, limit);
printf("Mean:\t\t%.5f (%.3f)\n", mean, mean * 100.0);
double variance = gsl_stats_variance_m(fuArray, 1, limit, mean);
printf("Variance:\t%.5f\n", variance);
double stddev = gsl_stats_sd_m(fuArray, 1, limit, mean);
printf("Std. Dev:\t%.5f\n", stddev);
double max = gsl_stats_max(fuArray, 1, limit);
printf("Max:\t\t%.5f (%.3f)\n", max, max * 100.0);
double min = gsl_stats_min(fuArray, 1, limit);
printf("Min:\t\t%.5f (%.3f)\n", min, min * 100.0);
printf("Total RTS:\t%d\n", rtsNr);
printf("Valid RTS:\t%d\n", validFuCnt);
printf("Invalid RTS:\t%d\n", invalidFuCnt);
}
int main(void)
{
double v[NEXP]; /* calculated volumes */
gsl_rng *r;
double mean, sd = 1;
int n, j;
unsigned long seed = 1UL;
long p = POINTS;
/* allocate random number generator */
r = gsl_rng_alloc(gsl_rng_taus2);
/* seed the random number generator */
gsl_rng_set(r, seed);
for (n = 1; n <= 9; n++)
{
while (sd >= .03)
{
for (j = 0; j < NEXP; j++)
{
/* calculate volume using Monte Carlo algorithm */
v[j] = mc_se(p, n, r);
}
mean = gsl_stats_mean(v, 1, NEXP);
sd = gsl_stats_sd_m(v, 1, NEXP, mean);
p *= 2;
}
printf("%d %10.8f %10.8f\n", n, mean, sd);
/* reset the standard deviation and the number of points at each iteration */
sd = 1;
p = POINTS;
}
gsl_rng_free(r);
return(0);
}
CAMLprim value ml_gsl_stats_sd(value ow, value omean, value data)
{
size_t len = Double_array_length(data);
double result;
if(ow == Val_none)
if(omean == Val_none)
result = gsl_stats_sd(Double_array_val(data), 1, len);
else
result = gsl_stats_sd_m(Double_array_val(data), 1, len,
Double_val(Unoption(omean)));
else {
value w = Unoption(ow);
check_array_size(data, w);
if(omean == Val_none)
result = gsl_stats_wsd(Double_array_val(w), 1,
Double_array_val(data), 1, len);
else
result = gsl_stats_wsd_m(Double_array_val(w), 1,
Double_array_val(data), 1, len,
Double_val(Unoption(omean)));
}
return copy_double(result);
}
