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); }