Example #1
0
def descStats(data):
    """
        Compute descriptive statistics of data
    """
    dataList = list(data)
    logDataList = list(N.log10(dataList))
    desc = dict()
    if len(dataList) == 0:
        desc['mean']       = 0
        desc['median']     = 0
        desc['logMean']    = 0
        desc['logMedian']  = 0
    elif len(dataList) < 2:
        desc['mean']       = dataList[0]
        desc['median']     = dataList[0]
        desc['logMean']    = logDataList[0]
        desc['logMedian']  = logDataList[0]
    else:
        desc['mean']       = mean(dataList)
        desc['median']     = median(dataList)
        desc['logMean']    = mean(logDataList)
        desc['logMedian']  = median(logDataList)

    if len(dataList) < 3:
        desc['stdev']      = 0
        desc['sterr']      = 0
        desc['logStdev']   = 0
        desc['logSterr']   = 0
    else:
        desc['stdev']      = std(dataList)
        desc['sterr']      = stderr(dataList)
        desc['logStdev']   = std(logDataList)
        desc['logSterr']   = stderr(logDataList)
    return desc
Example #2
0
 def test_2d(self):
     a = [[1.0, 2.0, 3.0], [2.0, 4.0, 6.0], [8.0, 12.0, 7.0]]
     b1 = array(
         (3.7859388972001824, 5.2915026221291814, 2.0816659994661335))
     b2 = array((1.0, 2.0, 2.64575131106))
     assert_array_almost_equal(stats.std(a), b1, 11)
     assert_array_almost_equal(stats.std(a, axis=0), b1, 11)
     assert_array_almost_equal(stats.std(a, axis=1), b2, 11)
Example #3
0
 def test_2d(self):
     a = [[1.0, 2.0, 3.0],
          [2.0, 4.0, 6.0],
          [8.0, 12.0, 7.0]]
     b1 = array((3.7859388972001824, 5.2915026221291814,
                 2.0816659994661335))
     b2 = array((1.0,2.0,2.64575131106))
     assert_array_almost_equal(stats.std(a),b1,11)
     assert_array_almost_equal(stats.std(a,axis=0),b1,11)
     assert_array_almost_equal(stats.std(a,axis=1),b2,11)
Example #4
0
File: misc.py Project: r-b-g-b/Lab
def errorfill(x, y, yerr = None, ax = None, color = None, err_type = 'sem', **kwargs):

	ax, fig = axis_check(ax)

	if color is None:
		color = ax._get_lines.color_cycle.next()

	if len(y.shape)==1:
		y_mean = y
	else:
		y_mean = y.mean(0)

	if yerr is None:
		if err_type == 'sem':
			yerr = 0.5*st.sem(y, 0)
		elif err_type == 'std':
			yerr = 0.5*st.std(y, 0)

	x_hi = y_mean + yerr
	x_lo = y_mean - yerr
	l = ax.plot(x, y_mean, color = color, **kwargs)
	l_up = ax.plot(x, y_mean+yerr, color = color, alpha = 0.2)
	l_lo = ax.plot(x, y_mean-yerr, color = color, alpha = 0.2)
	ax.fill_between(x, x_hi, x_lo, alpha = 0.2, color = color)
	
	return ax
Example #5
0
    def gStats(self, missingValue=0.0):
        """dict of {geneID: (min,max,mean,median,std,stderr,
        Shapiro-Wilk(w,p),normaltest_chisq (D'Agostino and Pearson),...}
        """
        import scipy as S
        import scipy.stats as SS

        rv = {}
        for k, v in self.items():
            # print k,v
            va = S.array(self.gValues(k, missingValue))

            try:
                normaltest = SS.normaltest(va)
            except:
                normaltest = None
            try:
                shapiro = SS.shapiro(va)
            except:
                shapiro = None

            try:
                rv[k] = (va.min(), va.max(), va.mean(), SS.median(va), SS.std(va), SS.stderr(va), normaltest, shapiro)
            except:
                print k, va
                raise
        return rv
Example #6
0
def _remove_outliers(data):
    return data
    if len(data) < 2:
        return data
    else:
        lmean = mean(data)
        limstdev = 3 * std(data)
        return [item for item in data if abs(item - lmean) < limstdev ]
Example #7
0
 def reindex(self):
     period = self.series[-self.period:]
     last = self.series[-1]
     try:
         dev = std(period)
         dev *= self.dev_factor
         dev += last
     except (TypeError, ZeroDivisionError, ):
         dev = None
     self.append(dev)
Example #8
0
 def reindex(self):
     periods = self.periods
     period = self.series[-periods:]
     vol = None
     if len(period) == periods:
         try:
             vol = std(period) / mean(period)
             vol *= 100
         except TypeError:
             pass
     self.append(vol)
Example #9
0
 def __init__(self, samples):
     self.samples = numpy.asarray(samples)
     self.N = len(samples)
     self.median = stats.median(samples)
     self.min = numpy.amin(samples)
     self.max = numpy.amax(samples)
     self.mean = stats.mean(samples)
     self.std = stats.std(samples)
     self.var = self.std**2.
     self.skew = stats.skew(samples)
     self.kurtosis = stats.kurtosis(samples)
     self.range = self.max - self.min
Example #10
0
 def _getcs(self, data):
     if self.c:
         c = data[self.c]
         #print data, c
         sigma, mu = std(c), mean(c)
         c = N.clip(c, mu - 2 * sigma, mu + 2 * sigma)
         c = (max(c) - c) / (max(c) - min(c))
     else:
         c = 'b'
     if self.s:
         s = data[self.s]
     else:
         s = 10.0
     return c, s
Example #11
0
 def _getcs(self, data):
     if self.c:
         c = data[self.c]
         #print data, c
         sigma, mu = std(c), mean(c)
         c = N.clip(c, mu - 2*sigma, mu + 2*sigma)
         c = (max(c) - c)/(max(c) - min(c))
     else:
         c = 'b'
     if self.s:
         s = data[self.s]
     else:
         s = 10.0
     return c, s
Example #12
0
def confidence(samples, confidence_level):
    """This function determines the confidence interval for a given set of samples, 
    as well as the mean, the standard deviation, and the size of the confidence 
    interval as a percentage of the mean.

    From javastats by Andy Georges.
    """
    mean = stats.mean(samples)
    sdev = stats.std(samples)
    n    = len(samples)
    df   = n - 1
    t    = distributions.t.ppf((1+confidence_level)/2.0, df)
    interval = (interval_low, interval_high) = ( mean - t * sdev / math.sqrt(n) , mean + t * sdev / math.sqrt(n) )
    interval_size = interval_high - interval_low
    interval_percentage = interval_size / mean * 100.0
    return (interval, mean, sdev, interval_percentage) 
Example #13
0
def skewsField(sample, field):
    """
    Checks whether the value of field in the passed in sample is significantly different from the
    value of field for the rest of the samples under consideration.
    """
    
    savedSamples = samples.sampleList[:]
    samples.sampleList.remove(sample)
    
    try:
        flds = samples.getAllFlds(field)
        
        mean = stats.mean(flds)
        stddev = stats.std(flds)
        val = sample[field]
        
        if stddev == 0:
            devs = 0
        else:
            devs = abs(val - mean) / stddev
    
    finally:
        #we should be fixing the sample list even when I crash!
        samples.sampleList = savedSamples
    
    if len(samples.sampleList) < 3:
        qual = confidence.Validity.plaus
    elif len(samples.sampleList) < 6:
        qual = confidence.Validity.prob
    else:
        qual = confidence.Validity.sound
        
    conf = __getConfidence((.5, 1, 2, 3, 5), devs, qual)
    
    samples.sampleList.sort(key=lambda x: samples.extractField(x, field))
    
    plot = __getPlot('id', field)
    plot.plotLine(0, mean)
    plot.plotLine(0, mean-stddev)
    plot.plotLine(0, mean+stddev)
    plot.plotLine(0, sample[field])
    
    return SimResult(conf, str(sample) + " has a different " + field + " from other samples",
                     str(sample) + "'s value for " + field + ' is ' + str(devs) + 
                     ' standard deviations from the mean', plot)
Example #14
0
def main():
    if( len(sys.argv) != 3 ):
        printUsage()

    executable = sys.argv[1]
    no_times = int(sys.argv[2])

    cmd = "time ./%s" % executable

    times = zeros(no_times, 'f');

    for i in range(no_times):
        t = time(); os.system(cmd); t_store = time() - t;
        print "t_store= ", t_store
        times[i] = t_store;

    print "Mean time for operation = ", mean(times)
    print "Standard deviation for operation = ", std(times)
Example #15
0
def fit_gaussians(data, initial_params, errs, profnm):
    numparams = len(initial_params)
    numgaussians = (len(initial_params)-1)/3
    # Generate the parameter structure
    parinfo = []
    params0 = []
    for ii in range(numparams):
        params0.append(initial_params[ii])
        parinfo.append({'value':initial_params[ii], 'fixed':0,
                        'limited':[0,0], 'limits':[0.,0.]})
    other_args = {'data':data, 'errs':errs}
    # Now fit it
    mpfit_out = mpfit.mpfit(fit_function, params0, functkw=other_args,
                            parinfo=parinfo, quiet=1)
    fit_params = mpfit_out.params
    fit_errs = mpfit_out.perror
    # degrees of freedom
    dof = len(data) - len(fit_params)
    # chi-squared for the model fit
    chi_sq = mpfit_out.fnorm
    print "------------------------------------------------------------------"
    print "Multi-Gaussian Fit by pygaussfit.py of '%s'"%profnm
    print "------------------------------------------------------------------"
    print "mpfit status:", mpfit_out.status
    print "gaussians:", numgaussians
    print "DOF:", dof
    print "chi-sq: %.2f" % chi_sq
    print "reduced chi-sq: %.2f" % (chi_sq/dof)
    residuals = data - gen_gaussians(fit_params, len(data))
    print "residuals  mean: %.3g"%mean(residuals)
    print "residuals stdev: %.3g"%std(residuals)
    print "--------------------------------------"
    print " const = %.5f +/- %.5f" % (fit_params[0], fit_errs[0])
    for ii in range(numgaussians):
        print " phas%d = %.5f +/- %.5f" % (ii+1, fit_params[1+ii*3], fit_errs[1+ii*3])
        print " fwhm%d = %.5f +/- %.5f" % (ii+1, fit_params[2+ii*3], fit_errs[2+ii*3])
        print " ampl%d = %.5f +/- %.5f" % (ii+1, fit_params[3+ii*3], fit_errs[3+ii*3])
    print "--------------------------------------"
    return fit_params, fit_errs, chi_sq, dof
Example #16
0
def histo_plotter(x, SPECS):
    # the histogram of the data
    n, bins, patches = hist(x, 50, normed=0)
    setp(patches, 'facecolor', 'g', 'alpha', 0.75)
    for i in range(len(SPECS)):
        out_of_spec = 0
        for j in range(len(bins)):
            if (bins[j] <= SPECS[i]):
                setp(patches[j], 'facecolor', 'r', 'alpha', 0.75)
                out_of_spec = out_of_spec + n[j]
        out_summary="#of Samples Below "+str(SPECS[i])+" :"+str(out_of_spec)+\
       "\n From "+str(len(x))+" Samples "
    fp3.write(out_summary)
    #print patches
    # add a 'best fit' line
    mu = stats.mean(x)
    sigma = stats.std(x)
    maxfreq = max(n)
    minval = min(x)
    out_summary2 = "Minimum Value: " + fix(minval, 3)
    fp3.write(out_summary2)
    #  print x, bins, n, mu, sigma
    y = normpdf(bins, mu, sigma)
    l = plot(bins, y, 'r--')
    #y = normpdf( bins)
    #l = plot(bins, n, 'r--')
    setp(l, 'linewidth', 1)
    xlabel('Clearance')
    ylabel('Count')
    title(r'$\rm{Histogram\ of\ Clearance}$')
    axis([bins[0], bins[49], 0.0, maxfreq])
    text(.01 + bins[0], .9 * maxfreq, out_summary, color='r')
    text(.01 + bins[0], .8 * maxfreq, out_summary2, color='b')
    grid(True)

    #savefig('histogram_demo',dpi=72)
    show()
Example #17
0
 def test_stdX(self):
     y = stats.std(X)
     assert_almost_equal(y, 2.738612788)
Example #18
0
 def test_std(self):
     y = stats.std(self.testcase)
     assert_approx_equal(y,1.290994449)
Example #19
0
 def test_stdHUGE(self):
     y = stats.std(HUGE)
     assert_approx_equal(y, 2.738612788e12)
Example #20
0
 def test_basic(self):
     a = [3,4,5,10,-3,-5,6]
     b = [3,4,5,10,-3,-5,-6]
     assert_almost_equal(stats.std(a),5.2098807225172772,11)
     assert_almost_equal(stats.std(b),5.9281411203561225,11)
Example #21
0
 def test_stdBIG(self):
     y = stats.std(BIG)
     assert_almost_equal(y, 2.738612788)
Example #22
0
 def calculate_mean_std(metric):
     values = list(perf[metric].values())
     perf['metrics'][metric]['mean'] = np.mean(values)
     perf['metrics'][metric]['std'] = std(values)
Example #23
0
def cross_validation(X, y, n_trials=5, trial_splits=None, fname=None):
    """Perform model selection via 5-fold cross validation"""
    # filter samples with no annotations
    del_rid = np.where(y.sum(axis=1) == 0)[0]
    y = np.delete(y, del_rid, axis=0)
    X = np.delete(X, del_rid, axis=0)

    # range of hyperparameters
    C_range = 10.**np.arange(-1, 3)
    gamma_range = 10.**np.arange(-3, 1)

    # pre-generating kernels
    print("### Pregenerating kernels...")
    K_rbf = {}
    for gamma in gamma_range:
        K_rbf[gamma] = rbf_kernel(X, gamma=gamma)
    print("### Done.")

    # performance measures
    perf = dict()
    pr_micro = []
    pr_macro = []
    fmax = []
    acc = []

    if trial_splits is None:
        # shuffle and split training and test sets
        trials = ShuffleSplit(n_splits=n_trials,
                              test_size=0.2,
                              random_state=None)
        ss = trials.split(X)
        trial_splits = []
        for train_idx, test_idx in ss:
            trial_splits.append((train_idx, test_idx))

    it = 0
    for jj in range(0, n_trials):
        train_idx = trial_splits[jj][0]
        test_idx = trial_splits[jj][1]
        it += 1
        y_train = y[train_idx]
        y_test = y[test_idx]
        print("### [Trial %d] Perfom cross validation...." % (it))
        print("Train samples=%d; #Test samples=%d" %
              (y_train.shape[0], y_test.shape[0]))
        # setup for neasted cross-validation
        splits = ml_split(y_train)

        # parameter fitting
        C_opt = None
        gamma_opt = None
        max_aupr = 0
        for C in C_range:
            for gamma in gamma_range:
                # Multi-label classification
                cv_results = []
                for train, valid in splits:
                    clf = OneVsRestClassifier(svm.SVC(C=C,
                                                      kernel='precomputed',
                                                      probability=False),
                                              n_jobs=-1)
                    K_train = K_rbf[gamma][
                        train_idx[train], :][:, train_idx[train]]
                    K_valid = K_rbf[gamma][
                        train_idx[valid], :][:, train_idx[train]]
                    y_train_t = y_train[train]
                    y_train_v = y_train[valid]
                    y_score_valid = np.zeros(y_train_v.shape, dtype=float)
                    y_pred_valid = np.zeros_like(y_train_v)
                    idx = np.where(y_train_t.sum(axis=0) > 0)[0]
                    clf.fit(K_train, y_train_t[:, idx])
                    y_score_valid[:, idx] = clf.decision_function(K_valid)
                    y_pred_valid[:, idx] = clf.predict(K_valid)
                    perf_cv = evaluate_performance(y_train_v, y_score_valid,
                                                   y_pred_valid)
                    cv_results.append(perf_cv['m-aupr'])
                cv_aupr = np.median(cv_results)
                print("### gamma = %0.3f, C = %0.3f, AUPR = %0.3f" %
                      (gamma, C, cv_aupr))
                if cv_aupr > max_aupr:
                    C_opt = C
                    gamma_opt = gamma
                    max_aupr = cv_aupr
        print("### Optimal parameters: ")
        print("C_opt = %0.3f, gamma_opt = %0.3f" % (C_opt, gamma_opt))
        print("### Train dataset: AUPR = %0.3f" % (max_aupr))
        print("### Using full training data...")
        clf = OneVsRestClassifier(svm.SVC(C=C_opt,
                                          kernel='precomputed',
                                          probability=False),
                                  n_jobs=-1)
        y_score = np.zeros(y_test.shape, dtype=float)
        y_pred = np.zeros_like(y_test)
        idx = np.where(y_train.sum(axis=0) > 0)[0]
        clf.fit(K_rbf[gamma_opt][train_idx, :][:, train_idx], y_train[:, idx])

        # Compute performance on test set
        y_score[:, idx] = clf.decision_function(
            K_rbf[gamma_opt][test_idx, :][:, train_idx])
        y_pred[:, idx] = clf.predict(K_rbf[gamma_opt][test_idx, :][:,
                                                                   train_idx])
        perf_trial = evaluate_performance(y_test, y_score, y_pred)
        pr_micro.append(perf_trial['m-aupr'])
        pr_macro.append(perf_trial['M-aupr'])
        fmax.append(perf_trial['F1'])
        acc.append(perf_trial['acc'])
        print(
            "### Test dataset: AUPR['micro'] = %0.3f, AUPR['macro'] = %0.3f, F1 = %0.3f, Acc = %0.3f"
            % (perf_trial['m-aupr'], perf_trial['M-aupr'], perf_trial['F1'],
               perf_trial['acc']))
    perf['m-aupr_avg'] = np.mean(pr_micro)
    perf['m-aupr_std'] = std(pr_micro)
    perf['M-aupr_avg'] = np.mean(pr_macro)
    perf['M-aupr_std'] = std(pr_macro)
    perf['F1_avg'] = np.mean(fmax)
    perf['F1_std'] = std(fmax)
    perf['acc_avg'] = np.mean(acc)
    perf['acc_std'] = std(acc)

    if fname is not None:
        fout = open(fname, 'w')
        fout.write("aupr[micro], aupr[macro], F_max, accuracy\n")
        for ii in range(0, n_trials):
            fout.write(pr_micro[ii], pr_macro[ii], fmax[ii], acc[ii])
        fout.close()

    return perf
Example #24
0
 def test_stdTINY(self):
     y = stats.std(TINY)
     assert_almost_equal(y, 0.0)
Example #25
0
 def test_stdBIG(self):
     y = stats.std(BIG)
     assert_almost_equal(y, 2.738612788)
Example #26
0
def temporal_holdout(X,
                     y,
                     indx,
                     bootstrap,
                     fname,
                     goterms=None,
                     go_fname=None):
    """Perform temporal holdout validation"""

    X_train = X[indx['train'].tolist()]
    X_test = X[indx['test'].tolist()]
    X_valid = X[indx['valid'].tolist()]
    y_train = y['train'].tolist()
    y_test = y['test'].tolist()
    y_valid = y['valid'].tolist()
    if goterms is not None:
        goterms = goterms['terms'].tolist()

    # range of hyperparameters
    C_range = 10.**np.arange(-1, 3)
    gamma_range = 10.**np.arange(-3, 1)

    # pre-generating kernels
    print("### Pregenerating kernels...")
    K_rbf_train = {}
    K_rbf_test = {}
    K_rbf_valid = {}
    for gamma in gamma_range:
        K_rbf_train[gamma] = rbf_kernel(X_train, gamma=gamma)
        K_rbf_test[gamma] = rbf_kernel(X_test, X_train, gamma=gamma)
        K_rbf_valid[gamma] = rbf_kernel(X_valid, X_train, gamma=gamma)
    print("### Done.")
    print("Train samples=%d; #Test samples=%d" %
          (y_train.shape[0], y_test.shape[0]))

    # parameter fitting
    C_opt = None
    gamma_opt = None
    max_aupr = 0
    for C in C_range:
        for gamma in gamma_range:
            # Multi-label classification
            clf = OneVsRestClassifier(svm.SVC(C=C,
                                              kernel='precomputed',
                                              probability=False),
                                      n_jobs=-1)
            clf.fit(K_rbf_train[gamma], y_train)
            y_score_valid = clf.decision_function(K_rbf_valid[gamma])
            y_pred_valid = clf.predict(K_rbf_valid[gamma])
            perf = evaluate_performance(y_valid, y_score_valid, y_pred_valid)
            micro_aupr = perf['m-aupr']
            print("### gamma = %0.3f, C = %0.3f, AUPR = %0.3f" %
                  (gamma, C, micro_aupr))
            if micro_aupr > max_aupr:
                C_opt = C
                gamma_opt = gamma
                max_aupr = micro_aupr
    print("### Optimal parameters: ")
    print("C_opt = %0.3f, gamma_opt = %0.3f" % (C_opt, gamma_opt))
    print("### Train dataset: AUPR = %0.3f" % (max_aupr))
    print("### Computing performance on test dataset...")
    clf = OneVsRestClassifier(svm.SVC(C=C_opt,
                                      kernel='precomputed',
                                      probability=False),
                              n_jobs=-1)
    clf.fit(K_rbf_train[gamma_opt], y_train)

    # Compute performance on test set
    y_score = clf.decision_function(K_rbf_test[gamma_opt])
    y_pred = clf.predict(K_rbf_test[gamma_opt])

    # performance measures for bootstrapping
    perf = dict()
    pr_micro = []
    pr_macro = []
    fmax = []
    acc = []

    # individual goterms
    pr_goterms = {}
    for i in range(0, len(goterms)):
        pr_goterms[goterms[i]] = []

    for ind in bootstrap:
        perf_ind = evaluate_performance(y_test[ind], y_score[ind], y_pred[ind])
        pr_micro.append(perf_ind['m-aupr'])
        pr_macro.append(perf_ind['M-aupr'])
        fmax.append(perf_ind['F1'])
        acc.append(perf_ind['acc'])
        for i in range(0, len(goterms)):
            pr_goterms[goterms[i]].append(perf_ind[i])

    perf['m-aupr_avg'] = np.mean(pr_micro)
    perf['m-aupr_std'] = std(pr_micro)
    perf['M-aupr_avg'] = np.mean(pr_macro)
    perf['M-aupr_std'] = std(pr_macro)
    perf['F1_avg'] = np.mean(fmax)
    perf['F1_std'] = std(fmax)
    perf['acc_avg'] = np.mean(acc)
    perf['acc_std'] = std(acc)

    # trials
    fout = open(fname, 'w')
    fout.write("aupr[micro], aupr[macro], F_max, accuracy\n")
    for it in range(0, len(bootstrap)):
        fout.write(pr_micro[it], pr_macro[it], fmax[it], acc[it], "\n")
    fout.close()

    # write performance on individual GO terms
    if go_fname is not None:
        fout = open(go_fname, 'wb')
        print >> fout, "GO_id, AUPRs"
        for i in range(0, len(goterms)):
            print >> fout, goterms[i], sum(y_train[:, i]) / float(
                y_train.shape[0]),
            for pr in pr_goterms[goterms[i]]:
                print >> fout, pr,
            print >> fout
        fout.close()

    return perf
Example #27
0
 def test_stdZERO(self):
     y = stats.std(ZERO)
     assert_almost_equal(y, 0.0)
Example #28
0
 def test_stdX(self):
     y = stats.std(X)
     assert_almost_equal(y, 2.738612788)
Example #29
0
 def test_std(self):
     y = stats.std(self.testcase)
     assert_approx_equal(y, 1.290994449)
Example #30
0
 def test_stdROUND(self):
     y = stats.std(ROUND)
     assert_approx_equal(y, 2.738612788)
Example #31
0
 def test_nanstd_some(self):
     """Check nanstd when some values only are nan."""
     s = stats.nanstd(self.Xsome)
     assert_approx_equal(s, stats.std(self.Xsomet))
Example #32
0
def table_fit_many(table, ff, fit_bounds):
    if fit_bounds is not None:

        if (stats.std(fits, axis=0) > stats.std(fit.boot)).any():
            warnings.warn("BAD")
Example #33
0
 def test_nanstd_none(self):
     """Check nanstd when no values are nan."""
     s = stats.nanstd(self.X)
     assert_approx_equal(s, stats.std(self.X))
Example #34
0
    cc.cycle(dt,fixnuc = 0)
    
    if run % 5 == 0:
        cc.display(dt)

    length_proj = S.array(cc.length_proj)
    trajs_theta = S.array(cc.trajs_theta)
    trans12 = int(cc.temps_1 * 0.5)
    trans23 = int(cc.temps_2 * 0.5)

    if len(length_proj) > trans23:
        longueur_moyenne.append(stats.mean(length_proj[trans12:trans23]))
        angle_moyen.append(stats.mean(trajs_theta[trans12:trans23]))
        angle_maxi.append(reduce(maximum,abs(trajs_theta[trans12:trans23])))
        angle_onset.append(abs(trajs_theta[trans23]))
        ecartype.append(stats.std(trajs_theta[trans12:trans23]))
        duree1.append(cc.temps_1)
        duree2.append(cc.temps_2 - cc.temps_1)
        fname = 'cell'+str(run)
        cc.logging(fname,dt)
        
    else :
        print 'discarded cell # %d ' % run
    del cc



angle_moyen =  S.array(angle_moyen)
longueur_moyenne= S.array(longueur_moyenne)
ecartype =  S.array(ecartype)
duree2 = S.array(duree2)
Example #35
0
 def test_basic(self):
     a = [3, 4, 5, 10, -3, -5, 6]
     b = [3, 4, 5, 10, -3, -5, -6]
     assert_almost_equal(stats.std(a), 5.2098807225172772, 11)
     assert_almost_equal(stats.std(b), 5.9281411203561225, 11)
Example #36
0
def zscore(line):
    '''replacement for scipy.stats.z, but uses N-1 degrees of freedom,
    instead of N degrees of freedom'''
    return (line - np.mean(line))/stats.std(line)
Example #37
0
	from scipy import stats
	import sys
	
	ephemerides = ReadEphemeridesLog(sys.argv[1])
	
	comps = []
	for e in ephemerides:
		c = ComparePysolarToUSNO(e)
		comps.append(c)

	az_errors = [c.az_error for c in comps]
	alt_errors = [c.alt_error for c in comps]

	print '---------------------'
	print 'Azimuth stats'
	print 'Mean error: ' + str(stats.mean(az_errors))
	print 'Std dev: ' + str(stats.std(az_errors))
	print 'Min error: ' + str(stats.tmin(az_errors, None))
	print 'Max error: ' + str(stats.tmax(az_errors, None))

	print '----------------------'
	print 'Altitude stats'
	
	print 'Mean error: ' + str(stats.mean(alt_errors))
	print 'Std dev: '+ str(stats.std(alt_errors))
	print 'Min error: ' + str(stats.tmin(alt_errors, None))
	print 'Max error: ' + str(stats.tmax(alt_errors, None))

	WriteComparisonsToCSV(comps, 'pysolar_v_usno.csv')
Example #38
0
 def test_stdZERO(self):
     y = stats.std(ZERO)
     assert_almost_equal(y, 0.0)
Example #39
0
 def test_stdROUND(self):
     y = stats.std(ROUND)
     assert_approx_equal(y, 2.738612788)
Example #40
0
def calculate_mean_std(performance, metric):
    performance['metrics'][metric] = {}
    values = list(performance[metric].values())
    performance['metrics'][metric]['mean'] = np.mean(values)
    performance['metrics'][metric]['std'] = std(values)
Example #41
0
 def test_nanstd_none(self):
     """Check nanstd when no values are nan."""
     s = stats.nanstd(self.X)
     assert_approx_equal(s, stats.std(self.X))
Example #42
0
    from scipy import stats
    import sys

    ephemerides = ReadEphemeridesLog(sys.argv[1])

    comps = []
    for e in ephemerides:
        c = ComparePysolarToUSNO(e)
        comps.append(c)

    az_errors = [c.az_error for c in comps]
    alt_errors = [c.alt_error for c in comps]

    print '---------------------'
    print 'Azimuth stats'
    print 'Mean error: ' + str(stats.mean(az_errors))
    print 'Std dev: ' + str(stats.std(az_errors))
    print 'Min error: ' + str(stats.tmin(az_errors, None))
    print 'Max error: ' + str(stats.tmax(az_errors, None))

    print '----------------------'
    print 'Altitude stats'

    print 'Mean error: ' + str(stats.mean(alt_errors))
    print 'Std dev: ' + str(stats.std(alt_errors))
    print 'Min error: ' + str(stats.tmin(alt_errors, None))
    print 'Max error: ' + str(stats.tmax(alt_errors, None))

    WriteComparisonsToCSV(comps, 'pysolar_v_usno.csv')
Example #43
0
 def test_nanstd_some(self):
     """Check nanstd when some values only are nan."""
     s = stats.nanstd(self.Xsome)
     assert_approx_equal(s, stats.std(self.Xsomet))
Example #44
0
 def test_stdLITTLE(self):
     y = stats.std(LITTLE)
     assert_approx_equal(y, 2.738612788e-8)
Example #45
0
 def test_stdLITTLE(self):
     y = stats.std(LITTLE)
     assert_approx_equal(y, 2.738612788e-8)
Example #46
0
 def test_stdHUGE(self):
     y = stats.std(HUGE)
     assert_approx_equal(y, 2.738612788e12)
Example #47
0
 def test_stdTINY(self):
     y = stats.std(TINY)
     assert_almost_equal(y, 0.0)
Example #48
0
def plotB5(B5s,vpns,clrs=None,exps=[1],suffix=''):
    tt=0
    for gg in range(len(B5s)):
        B5=B5s[gg]; exp=exps[gg];vpn=vpns[gg]
        
        titles=['Recalled Position','Selected Position','Selected Position']
        posx=np.array([-6,-3,0,3,6,-6,-3,0],ndmin=2)
        seln=~np.isnan(B5[:,0,0])
        a=np.zeros(B5.shape[1]); a[:5]=1
        b=np.zeros(B5.shape[1]);
        if exp==1: b[5:10]=1
        else: b[5:]=1
        c=np.zeros(B5.shape[1]); c[10:]=1
        sels=[a==1,b==1];kk=1
        if exp==1: sels.append(c==1)
        if clrs is None or len(clrs)!=B5.shape[0]: clrs=getColors(B5.shape[0])
        #if gg==1: clrs=getColors(28)[:18]
        #elif gg==2: clrs=getColors(28)[18:]
        res=[]
        for sel in sels:
            objs=[]
            v=[]
            subplot(len(B5s),3,gg*3+kk);plt.grid(axis='y');kk+=1
            if exp==1: drawCircularAgent(pos=(0,0),eyes=kk<4)
            else: drawDartAgent(pos=(0,0))
            plt.plot([-1,1],[0,0],color='#262626',label='_nolegend_',lw=0.5);
            plt.plot([0,0],[-1,1],color='#262626',lw=0.5,label='_nolegend_')
            dx=B5[:,sel,1]-posx[0,:sel.sum()]
            dy=B5[:,sel,2]
            mag=np.sqrt(np.power(dx,2)+np.power(dy,2))
            if exp==1: phi=np.arctan2(dy,dx)-B5[:,sel,0]
            else:  phi=np.arctan2(dy,dx)-np.pi*B5[:,sel,0]/180
            xn=np.cos(phi)*mag
            yn=np.sin(phi)*mag
            for i in range(B5.shape[0]):
                plt.plot(xn[i,:],yn[i,:],'o',mfc=clrs[i],
                         label='_nolegend_',mew=0.15,alpha=0.5,ms=3,mec='k')
                valid=np.sqrt(np.power(xn[i,:],2)+np.power(yn[i,:],2))<1.2
                v.extend(valid.tolist())
                if seln[i]: label=str(vpn[i])
                else:label='_nolegend_'
                plt.plot(np.median(xn[i,valid]),np.median(yn[i,valid]),'x',
                              label=label,mec=clrs[i],mew=1.5,ms=6,zorder=3)
                xn[i,~valid]=np.nan
            plt.gca().set_aspect('equal')
            plt.xlim([-1,1]);plt.ylim([-1,1])
            #if kk>2: plt.gca().set_yticklabels([])
            if gg==0: plt.title(titles[kk-2],fontsize=12)
            #print np.array(v).sum(),float(seln.sum()), len(v)/float(xn.shape[0])
            res.append([xn])
            xn=xn.flatten()[np.array(v)]
            
            #if gg==1: xxn=np.copy(xn)
            #elif gg==2: xn=np.concatenate([xxn,xn])
            #xn=median(xn,1)
            m=np.mean(xn)
            plt.text(plt.xlim()[0]+0.1*(plt.xlim()[1]-plt.xlim()[0]),
                     plt.ylim()[1]-0.1*(plt.ylim()[1]-plt.ylim()[0]), 
                    str(unichr(65+tt)),horizontalalignment='center',verticalalignment='center',
                    fontdict={'weight':'bold'},fontsize=12);tt+=1
            plt.plot([m,m],[-1,1],'--g',color='gray',label='_nolegend_',zorder=-2)
            sse=std(xn,bias=True)/xn.size**0.5
            res[-1].extend([m,sse,xn.size])
            er= sse* stats.t.ppf(0.975,xn.size)
            er=[m-2*er,m+2*er]#[sap(xn,25),sap(xn,75)]
            plt.gca().add_patch(plt.Rectangle([er[0],-5],er[1]-er[0],10,
                                    color='k',zorder=-2,alpha=0.1))
            print " %.3f CI [%.3f, %.3f]"%(m,er[0],er[1])
            if False:#kk==2:
                plt.legend(bbox_to_anchor=(0,0,1,1),loc=2,mode="expand",ncol=seln.sum()/2+1,
                    bbox_transform=plt.gcf().transFigure,frameon=False)
            if exp==2:
                x0=(1-3**0.5/2)*AR
                for i in range(2):
                    plt.plot([x0,x0],[-1,1],':',color='gray')
    return res
def least_squers_fit(x, y):
    beta = numpy.corrcoef(x, y) * st.std(y) / st.std(x)
    alpha = numpy.mean(y) - beta * numpy.mean(x)
    return alpha, beta