def setData(x, y): #进行数据处理 xdata = { 'avg': None, 'stdev': None, 'pstdev': None, 'var': None, 'pvar': None } ydata = { 'avg': None, 'stdev': None, 'pstdev': None, 'var': None, 'pvar': None } xdata['avg'] = round(mean(x), 3) ydata['avg'] = round(mean(y), 3) xdata['stdev'] = round(stdev(x), 3) ydata['stdev'] = round(stdev(y), 3) xdata['pstdev'] = round(pstdev(x), 3) ydata['pstdev'] = round(pstdev(y), 3) xdata['var'] = round(variance(x), 3) ydata['var'] = round(variance(y), 3) xdata['pvar'] = round(pvariance(x), 3) ydata['pvar'] = round(pvariance(y), 3) return xdata, ydata
def test_prune(self): with get_session(bind=get_engine("sqlite:///:memory:")) as session: session.add(CpuPercent(core_id=0, mean=2)) session.add(CpuPercent(core_id=0, mean=3)) session.add(CpuPercent(core_id=1, mean=4)) session.add(CpuPercent(core_id=1, mean=4)) session.add(CpuPercent(core_id=1, mean=5)) with get_session(bind=get_engine("sqlite:///:memory:")) as session: metrics = list(session.query(CpuPercent)) core0, core1 = CpuPercent.prune(metrics) self.assertAlmostEqual(core0.mean, statistics.mean((2, 3)), places=10) self.assertAlmostEqual(core0.variance, statistics.pvariance((2, 3)), places=10) self.assertEqual(core0.sample_count, 2) self.assertAlmostEqual(core1.mean, statistics.mean((4, 4, 5)), places=10) self.assertAlmostEqual(core1.variance, statistics.pvariance((4, 4, 5)), places=10) self.assertEqual(core1.sample_count, 3)
def apListeVA(i): """met à jour les listes des vitesses, variances et carrée des accélérations, variances pour l'indice i de la matrice cellules.""" listesVA["v"].append(mean(listVA(i)[0])) listesVA["varV"].append(pvariance(listVA(i)[0])) listesVA["a"].append(mean(listVA(i)[1])) listesVA["varA"].append(pvariance(listVA(i)[1]))
def PVARIANCE(df, n, price='Close', mu=None): """ Population variance of data """ pvariance_list = [] i = 0 if n == len(df[price]): start = None while i < len(df[price]): if df[price][i] != df[price][i]: pvariance = float('NaN') else: if start is None: start = i end = i + 1 pvariance = statistics.pvariance(df[price][start:end], mu) pvariance_list.append(pvariance) i += 1 else: while i < len(df[price]): if i + 1 < n: pvariance = float('NaN') else: start = i + 1 - n end = i + 1 pvariance = statistics.pvariance(df[price][start:end], mu) pvariance_list.append(pvariance) i += 1 return pvariance_list
def staData(x, y): xsta = { 'avg': None, 'stdev': None, 'pstdev': None, 'var': None, 'pvar': None } ysta = { 'avg': None, 'stdev': None, 'pstdev': None, 'var': None, 'pvar': None } xsta['avg'] = mean(x) ysta['avg'] = mean(y) xsta['stdev'] = stdev(x) ysta['stdev'] = stdev(y) xsta['pstdev'] = pstdev(x) ysta['pstdev'] = pstdev(y) xsta['var'] = variance(x) ysta['var'] = variance(y) xsta['pvar'] = pvariance(x) ysta['pvar'] = pvariance(y) r = np.corrcoef(x, y)[0, 1] return xsta, ysta, r
def test_up_pvar(): data = [random.randrange(1, 100) for i in range(20)] m1 = statistics.mean(data[:-1]) pvar0 = statistics.pvariance(data) pvar1 = statistics.pvariance(data[:-1]) delta = abs(pvar0 - cjrh_math.update_pvariance(19, m1, pvar1, data[-1])) assert delta < 1e-8
def compute_stats(df): days = [] mean_mag_JJY = [] disp_mag_JJY = [] mean_phase_JJY = [] disp_phase_JJY = [] DFList = [] # df['A_jjy']=df['A_jjy'].replace(to_replace=0, method='ffill',limit=180).values #Forward fill 0 values # df['P_jjy']=df['P_jjy'].replace(to_replace=0, method='ffill',limit=180).values #Forward fill 0 values for group in df.groupby(df.index.date): DFList.append(group[1]) for day in DFList: days.append(day.index[0]) day.astype(bool).sum(axis=0) A_zeros = day.shape[0] - day['A_jjy'].astype(bool).sum(axis=0) P_zeros = day.shape[0] - day['P_jjy'].astype(bool).sum(axis=0) if (A_zeros > 360 or P_zeros > 360): mean_mag_JJY.append(np.nan) mean_phase_JJY.append(np.nan) disp_mag_JJY.append(np.nan) disp_phase_JJY.append(np.nan) else: mean_mag_JJY.append(stat.mean(day['A_jjy'])) mean_phase_JJY.append(stat.mean(day['P_jjy'])) disp_mag_JJY.append(stat.pvariance(day['A_jjy'])) disp_phase_JJY.append(stat.pvariance(day['P_jjy'])) d = { 'mean_mag_JJY': mean_mag_JJY, 'mean_phase_JJY': mean_phase_JJY, 'disp_mag_JJY': disp_mag_JJY, 'disp_phase_JJY': disp_phase_JJY } stats_df = pd.DataFrame(data=d, index=days) # stats_df=stats_df.drop(stats_df.index[0]) #Drop first row as only 3 sampls return stats_df
def PVARIANCE(df, n, price='Close', mu=None): """ Population variance of data Returns: list of floats = jhta.PVARIANCE(df, n, price='Close', mu=None) """ pvariance_list = [] if n == len(df[price]): start = None for i in range(len(df[price])): if df[price][i] != df[price][i]: pvariance = float('NaN') else: if start is None: start = i end = i + 1 pvariance = statistics.pvariance(df[price][start:end], mu) pvariance_list.append(pvariance) else: for i in range(len(df[price])): if i + 1 < n: pvariance = float('NaN') else: start = i + 1 - n end = i + 1 pvariance = statistics.pvariance(df[price][start:end], mu) pvariance_list.append(pvariance) return pvariance_list
def severalanova2(sa1, sd1, sa2, sd2, sa3, sd3, number123, numberrun): import statistics in_i=0 in_A=[] numberrun=numberrun-1 while in_i<=numberrun: in_i = in_i +1 inlist1= getnormal (sa1, sd1, number123) inlist2= getnormal (sa2, sd2, number123) inlist3= getnormal (sa3, sd3, number123) variance1=statistics.pvariance(inlist1) ilist1=0 while ilist1<len(inlist1): inlist1[ilist1]=float(inlist1[ilist1])/float(variance1) ilist1=ilist1+1 variance2=statistics.pvariance(inlist2) ilist2=0 while ilist2<len(inlist2): inlist2[ilist2]=float(inlist2[ilist2])/float(variance2) ilist2=ilist2+1 variance3=statistics.pvariance(inlist3) ilist3=0 while ilist3<len(inlist3): inlist3[ilist3]=float(inlist3[ilist3])/float(variance3) ilist3=ilist3+1 in_a=onewayanova(inlist1, inlist2, inlist3) in_A.append(in_a) return in_A
def get_stats(file): filename = basename(file) algorithm, key_length, _ = filename.split('-') f = open(file) lines = f.readlines() f.close() error_rate = [] correct = [] ber = [] efficiency = [] channel_uses = [] msg_len = [] for line in lines[1:]: split = line.replace('\n', '').split(',') error_rate.append(float(split[2])) correct.append(split[4] == 'True') if correct[-1]: efficiency.append(float(split[6])) else: ber.append(float(split[5])) channel_uses.append(int(split[7])) msg_len.append(int(split[8])) if not ber: ber = [0, 0] return algorithm, key_length, error_rate[0], mean(efficiency), pvariance(efficiency), 1 - ( sum(correct) / len(error_rate)), mean(ber), pvariance(ber), mean(channel_uses), pvariance(channel_uses), \ mean(msg_len), pvariance(msg_len)
def satData(x, y): xsta = { 'avg': None, 'stdev': None, 'pstdev': None, 'var': None, 'pvar': None } #x的数据处理,将各个数放入字典中 ysta = { 'avg': None, 'stdev': None, 'pstdev': None, 'var': None, 'pvar': None } #y的数据处理,将各个数放入字典中 xsta['avg'] = mean(x) #x平均数 ysta['avg'] = mean(y) #y平均数 xsta['stdev'] = stdev(x) #x标准差 ysta['stdev'] = stdev(y) #y标准差 xsta['pstdev'] = pstdev(x) #x样本总体的标准偏差 ysta['pstdev'] = pstdev(y) #x样本总体的标准偏差 xsta['var'] = variance(x) #x方差 ysta['var'] = variance(y) #y方差 xsta['pvar'] = pvariance(x) #x样本总体的方差 ysta['pvar'] = pvariance(y) #y样本总体的方差 r = np.corrcoef(x, y)[0, 1] #x、y的相关性系数 return xsta, ysta, r #返回各数
def log_evaluation(self, population: 'Population', **kwargs): count_penalization = 0 partitions = list() fitnesses = list() costs = list() generation = population.generation for individual in population: qtd = individual.qtd_partitions if qtd > 1: count_penalization += 1 partitions.append(qtd) fitnesses.append(individual.fitness) costs.append(individual.cost) currentbest = population.current_best bestoverall = population.documented_best self.log("evaluation", generation, fmean(costs), pvariance(costs), fmean(fitnesses), pvariance(fitnesses), count_penalization, fmean(partitions), pvariance(partitions), currentbest.cost, currentbest.fitness, bestoverall.cost, bestoverall.fitness, bestoverall.last_improvement)
def covariances(var1,var2,debut,fin): indices,dates=calcul_temps(debut,fin) res = 0 l1=[var1[j] for j in indices] l2=[var2[k] for k in indices] m1=st.mean(l1) m2=st.mean(l2) for i in indices : res += var1[i]*var2[i] return res-(m1*m2),math.sqrt(st.pvariance(l1,m1)),math.sqrt(st.pvariance(l2,m2))
def compute(self, ydata): y = np.swapaxes(ydata,0,1).T var_ls = sum([sum([statistics.pvariance(y[k][w],mu=self.n_run.full_logsampNz[k]) for k in self.n_run.binnos])/self.n_run.nwalkers**2 for w in self.n_run.walknos]) var_s = sum([sum([statistics.pvariance(np.exp(y[k][w]),mu=self.n_run.full_sampNz[k]) for k in self.n_run.binnos])/self.n_run.nwalkers**2 for w in self.n_run.walknos]) self.tot_ls = self.tot_ls+var_ls self.tot_s = self.tot_s+var_s return { 'tot_ls': self.tot_ls, 'tot_s': self.tot_s, 'var_ls': var_ls, 'var_s': var_s }
def do_it(): cols = defaultdict(list) for line in sys.stdin: fields = line.split(maxsplit=1) cols[fields[1].strip()].append(float(fields[0])) print('col\tmin\tmax\tavg\tharm\tmed\tvar') for col, vals in cols.items(): if statistics.pvariance(vals) == 0.0: continue print('{}\t{:.6f}\t{:.6f}\t{:.6f}\t{:.6f}\t{:.6f}\t{:.6f}'.format( col, min(vals), max(vals), statistics.mean(vals), statistics.harmonic_mean(vals), statistics.median_low(vals), statistics.pvariance(vals)))
def main(): """ Run evaluation for a model on a test file of given set size. The model will by default run 50 samples. Prints rouge variance of rouge scores and validation score to console, as well as the avg. set validation time. """ args, unknown_args = prepare_arg_parser().parse_known_args() model_file = args.model_file test_file = args.test_file set_size = args.set_size samples = args.samples with suppress_stdout_stderr(): model, _optimizer, vocab, _stats, cfg = train.load_model( model_file, unknown_args) model.eval() dataset = Dataset(test_file, vocab, cfg) r1_scores = [] r2_scores = [] rl_scores = [] validation_scores = [] times = [] for i in range(samples): print("Step:", i) start = time.time() with suppress_stdout_stderr(): scores = evaluate.evaluate(model, dataset, cfg, limit=set_size, shuffle=True) r1_scores.append(scores["rouge-1"]["f"] * 100) r2_scores.append(scores["rouge-2"]["f"] * 100) rl_scores.append(scores["rouge-l"]["f"] * 100) validation_scores.append(calc_validation_score(scores)) times.append(time.time() - start) print(f"Test File: {test_file}, Set Size: {set_size}, Samples: {samples}") r1_v, r2_v, rl_v = pvariance(r1_scores), pvariance(r2_scores), pvariance( rl_scores) valid_v = pvariance(validation_scores) avg_time = mean(times) print( "r1_variance,r2_variance,rl_variance,validation_variance,avg_time_for_set" ) print("%.2f,%.2f,%.2f,%.2f,%d" % (r1_v, r2_v, rl_v, valid_v, avg_time))
def statsLigne(ligne): """ligne : une ligne de la matrice cellules. en sortie : vitesse moyenne v_i et variance associée v_iVar, cumule de pollution pol_i et variance associée pol_iVar.""" if ligne == []: return 0, 0, 0, 0 v, p = [], [] for i in range(len(ligne)): if ligne[i][5] != -1: v.append(ligne[i][4]) p.append(ligne[i][3]**2) return round(mean(v), 3), round(pvariance(v), 3), round(sum(p), 3), round(pvariance(p), 3)
def extractionFeaturesColor(self, image_path): self.image_path = image_path try: imgIN = Image.open(self.image_path) img = imgIN.convert('RGB') vr, vg, vb, features = [],[],[],[] maxHistogram = 256 histR,histG,histB = [0] * maxHistogram, [0] * maxHistogram, [0] * maxHistogram HgR, HgG, HgB = 0,0,0 for i in range(img.size[0]): for j in range(img.size[1]): r, g, b = img.getpixel((i,j)) vr.append(r), vg.append(g), vb.append(b) histR[r] += 1 histG[g] += 1 histB[b] += 1 if (r > HgR): HgR = r if (g > HgG): HgG = g if (b > HgB): HgB = b features.append(statistics.mean(vr)) , features.append(statistics.mean(vg)), features.append(statistics.mean(vb)) features.append(statistics.mode(vr)), features.append(statistics.mode(vg)), features.append(statistics.mode(vb)) features.append(statistics.pvariance(vr)), features.append(statistics.pvariance(vg)), features.append(statistics.pvariance(vb)) features.append(statistics.pstdev(vr)), features.append(statistics.pstdev(vg)), features.append(statistics.pstdev(vb)) features.append(statistics.variance(vr)), features.append(statistics.variance(vg)), features.append(statistics.variance(vb)) features.append(statistics.stdev(vr)), features.append(statistics.stdev(vg)), features.append(statistics.stdev(vb)) entropyR, entropyG, entropyB = 0,0,0 energyR, energyG, energyB = 0,0,0 for i in range(HgR): energyR += (histR[i] ** 2) if (histR[i] != 0): entropyR += -histR[i] * math.log2(histR[i]) for i in range(HgG): if (histG[i] != 0): entropyG += -histG[i] * math.log2(histG[i]) energyG += (histG[i] ** 2) for i in range(HgB): energyB += (histB[i] ** 2) if (histB[i] != 0): entropyB += -histB[i] * math.log2(histB[i]) features.append(energyR), features.append(energyG), features.append(energyB) # Energy features.append(entropyR), features.append(entropyG), features.append(entropyB) # Entropy #features.append(statistics.median_high(vr)) , features.append(statistics.median_high(vg)), features.append(statistics.median_high(vb)) #features.append(statistics.median_low(vr)) , features.append(statistics.median_low(vg)), features.append(statistics.median_low(vb)) return features except Exception as e: print('\n################# (LBP) - Error Reading Image! #################\n', e)
def afStatistiques(stats_i, listeV, listeP, statMenu): """stats_i: [v_i,v_iVar,pol_i,pol_iVar] listeV,listeP: liste des vitesses moyennes et pollutions cumulées statMenu: liste des objets IntVar qui affichent les valeurs des statistiques. """ polMoy = mean(listeP) statMenu[0].set(stats_i[0]) statMenu[1].set(stats_i[1]) statMenu[2].set(round(mean(listeV), 3)) statMenu[3].set(round(pvariance(listeV), 3)) statMenu[4].set(stats_i[2]) statMenu[5].set(stats_i[3]) statMenu[6].set(round(polMoy, 3)) statMenu[7].set(round(pvariance(listeP), 3)) statMenu[8].set(round(polMoy * (len(listeP)), 0))
def statVA(i, listeV, listeP, ligne): """i : indice correspondant au temps listeV, listeP : liste des vitesses moyennes et des cumules de pollution ligne : liste de cellules[i] renvoie les statistiques v_i, v_iVar, v, vVar et pol_i, pol_iVar, pol, polVar et pollution cumulée.""" polMoy = mean(listeP[:i + 1]) v_iVar = statsLigne(ligne)[1] pol_iVar = statsLigne(ligne)[3] return (listeV[i], v_iVar, round(mean(listeV[:i + 1]), 3), round(pvariance(listeV[:i + 1]), 3), listeP[i], pol_iVar, round(polMoy, 3), round(pvariance(listeP[:i + 1]), 3), round(polMoy * (i + 1), 0))
def score_clause(self,clause): """multiprocessing scoring function """ examples = self.examples data = self.facts example_list = list(examples.keys()) n = len(example_list) true_examples = {} false_examples = {} score_val = 0.0 Prover.rule = clause Prover.facts = data result = [] for example in example_list: result.append(Prover.prove_rule(example)) for i in range(n): if (not not result[i]): true_examples[example_list[i]] = examples[example_list[i]] else: false_examples[example_list[i]] = examples[example_list[i]] nt = len(true_examples) nf = len(false_examples) n = nt+nf if Node.score == "IG": left_entropy = entropy(list(true_examples.values())) right_entropy = entropy(list(false_examples.values())) ig = (nt*left_entropy)/n + (nf*right_entropy)/n score_val = ig elif Node.score == "WV": left_variance = 0 try: left_variance = pvariance(list(true_examples.values())) except: left_variance = 0 right_variance = 0 try: right_variance = pvariance(list(false_examples.values())) except: right_variance = 0 wv = (nt*left_variance)/n + (nf*right_variance)/n score_val = wv return ((score_val,true_examples,false_examples))
def stats_helper(list): """ https://docs.python.org/3/library/statistics.html#statistics.pvariance :param list: :return: """ mean = statistics.mean(list) mode = None try: mode = statistics.mode(list) except statistics.StatisticsError: # no unique mode pass return { 'mean': mean, 'variance': statistics.pvariance(list, mu=mean), 'standard_deviation': statistics.pstdev(list, mu=mean), 'median': statistics.median(list), 'median_low': statistics.median_low(list), 'median_high': statistics.median_high(list), 'median_grouped': statistics.median_grouped(list), 'mode': mode }
def statistics_variance(): import subprocess def get_Line_lengths(): # ! works ONLY on unix-like system tho .. cmd = 'wc -l ../[a-z]*/*.py' out = subprocess.check_output(cmd, shell=True).decode('utf8') for line in out.splitlines(): parts = line.split() if parts[1].strip().lower() == 'total': break nlines = int(parts[0].strip()) if not nlines: continue yield (nlines, parts[1].strip()) data = list(get_Line_lengths()) lengths = [d[0] for d in data] sample = lengths[::2] print('Basic statistics:') print(' count : {:3d}'.format(len(lengths))) print(' min : {:6.2f}'.format(min(lengths))) print(' max : {:6.2f}'.format(max(lengths))) print(' mean : {:6.2f}'.format(statistics.mean(lengths))) print('\nPopulation variance:') print(' pstdev : {:6.2f}'.format(statistics.pstdev(lengths))) print(' pvariance : {:6.2f}'.format(statistics.pvariance(lengths))) print('\nEstimated variance for sample:') print(' count : {:3d}'.format(len(sample))) print(' stdev : {:6.2f}'.format(statistics.stdev(sample))) print(' variance : {:6.2f}'.format(statistics.variance(sample)))
def variance(town, strng): firstTreat=strng.split('\n') secondTreat=[] for i in range(len(firstTreat)): secondTreat.append(firstTreat[i].split(':')) count=0 for i in secondTreat: if i[0]==town: count +=1 break if count == 0: return -1 dic_data={} thirdTreat=[] for i in secondTreat: if i[0]==town: thirdTreat=i[1].split(',') break forthTreat=[] for i in thirdTreat: forthTreat.append(i.split(' ')) for i in forthTreat: dic_data[i[0]]=float(i[1]) values = dic_data.values() import statistics return statistics.pvariance(values)
def create_stats_report(data: list = None): if data is None: # converting to a list in case a generator was returned data = list(get_all_line_counts()) # taking a sample for the last section sample = list(data)[::2] # TODO 2: complete this dict, use data list and # for the last 3 sample_ variables, use sample list stats = dict( count=None, min_=None, max_=None, mean=None, pstdev=None, pvariance=None, sample_count=None, sample_stdev=None, sample_variance=None, ) stats['count'] = len(data) stats['min_'] = min(data) stats['max_'] = max(data) stats['mean'] = statistics.mean(data) stats['pstdev'] = statistics.pstdev(data) stats['pvariance'] = statistics.pvariance(data) stats['sample_count'] = len(sample) stats['sample_stdev'] = statistics.stdev(sample) stats['sample_variance'] = statistics.variance(sample) return STATS_OUTPUT.format(**stats)
def test_secint(self): secint = mpc.SecInt() y = [1, 3, -2, 3, 1, -2, -2, 4] * 5 random.shuffle(y) x = list(map(secint, y)) self.assertEqual(mpc.run(mpc.output(mean(x))), round(statistics.mean(y))) self.assertEqual(mpc.run(mpc.output(variance(x))), round(statistics.variance(y))) self.assertEqual(mpc.run(mpc.output(variance(x, mean(x)))), round(statistics.variance(y))) self.assertEqual(mpc.run(mpc.output(stdev(x))), round(statistics.stdev(y))) self.assertEqual(mpc.run(mpc.output(pvariance(x))), round(statistics.pvariance(y))) self.assertEqual(mpc.run(mpc.output(pstdev(x))), round(statistics.pstdev(y))) self.assertEqual(mpc.run(mpc.output(mode(x))), round(statistics.mode(y))) self.assertEqual(mpc.run(mpc.output(median(x))), round(statistics.median(y))) self.assertEqual(mpc.run(mpc.output(median_low(x))), round(statistics.median_low(y))) self.assertEqual(mpc.run(mpc.output(median_high(x))), round(statistics.median_high(y))) self.assertEqual(mpc.run(mpc.output(quantiles(x[:2], n=3))), statistics.quantiles(y[:2], n=3)) self.assertEqual(mpc.run(mpc.output(quantiles(x, n=1))), statistics.quantiles(y, n=1)) self.assertEqual(mpc.run(mpc.output(quantiles(x))), statistics.quantiles(y)) x = list(range(16)) y = list(reversed(x)) self.assertAlmostEqual(covariance(x, y), -22.667, 3) x = list(map(secint, x)) y = list(map(secint, y)) self.assertEqual(mpc.run(mpc.output(covariance(x, y))), -23) self.assertRaises(ValueError, quantiles, x, method='wrong')
def st_dev(): from statistics import pstdev, mean,median,mode, pvariance from scipy import stats from matplotlib import pyplot as plt entry=[] sizeplt=[] count=0 size =int(input("Enter number of days: ")) while count<size: val = int(input("Please enter {}. day cases: ".format(count+1))) entry.append(val) count += 1 print("Mean is: ",(mean(entry))) print("Variance is:", (pvariance(entry))) print("Standard Deviation is:", (pstdev(entry))) print("Mode is:", (mode(entry))) print("Coefficient of Variation:",stats.variation(entry)) print("Z Scores are:",stats.zscore(entry)) print("Median is:", (median(entry))) for z in range(1,len(entry)+1): sizeplt.append(z) plt.plot(sizeplt,entry) plt.title("Turkey Covid-19 Daily Date Information") plt.xlabel("Day") plt.ylabel("Cases") plt.show()
def getreport_data(close_list, today_dict): #Statistical Analysis today_date = today_dict['date'][0] today_price = today_dict['price'][0] diff1 = today_dict['change'][0] days = int(len(close_list)) days3 = days-4 days5 = days-6 days14 = days-15 diff3 = today_price - (close_list[0:days3][-1]) diff5 = today_price - (close_list[0:days5][-1]) diff14 = today_price - (close_list[0:days14][-1]) mean = stat.mean(close_list) median = stat.median(close_list) var = stat.pvariance(close_list, mean) stdev = stat.pstdev(close_list) price_greater = [] price_less = [] for price in close_list: if today_price >= price: price_less.append(price) else: price_greater.append(price) percentile = float(len(price_less))/float(len(close_list)) price_dict = {'today_date': today_date, 'today_price': today_price, 'diff1': diff1, 'diff3': diff3, 'diff5':diff5, 'diff14':diff14} stat_dict = {'mean': mean, 'median': median, 'stdev': stdev, 'var': var, 'percentile' : percentile} return [price_dict, stat_dict]
def main(): statistics_data = {} for file_name in file_names: statistics_data[file_name] = {} file_data = pd.read_csv(file_name) file_data.dropna(subset=['CO', 'SO2', 'NO2'], inplace=True) for col_name in ['CO', 'SO2', 'NO2']: statistics_data[file_name][col_name] = {} statistics_data[file_name][col_name]['mean'] = statistics.mean( file_data[col_name]) statistics_data[file_name][col_name][ 'harmonic_mean'] = statistics.harmonic_mean( file_data[col_name]) statistics_data[file_name][col_name]['media'] = statistics.median( file_data[col_name]) statistics_data[file_name][col_name][ 'low_median'] = statistics.median_low(file_data[col_name]) statistics_data[file_name][col_name][ 'high_median'] = statistics.median_high(file_data[col_name]) statistics_data[file_name][col_name][ 'population_std_dev'] = statistics.pstdev(file_data[col_name]) statistics_data[file_name][col_name][ 'population_variance'] = statistics.pvariance( file_data[col_name]) statistics_data[file_name][col_name][ 'sample_std_dev'] = statistics.stdev(file_data[col_name]) statistics_data[file_name][col_name][ 'sample_variance'] = statistics.variance(file_data[col_name]) create_plots(statistics_data)
def getStatIndicators(l, m): """ input l : List : set of times m : int. Number of parallel machines Return a tuple with followings values meanPerMachine, Work_Time, mean (Arithmetical), mean (Geometric); mean (harmonic); median; mode, minimum, maximum, standard_deviation, variance """ # ---------------------------------------------------------- # mu # to call it one time (used in mean, pstdev and pvariance) # if this parameter is not injected into pstdev and pvariance, # these functions re compute the mean. # ---------------------------------------------------------- mu = stat.mean(l) return ( getMeanTimePerMachine(l, m), getMeanTimePerMachine(l, m), stat.mean(l), sc.gmean(l), 0, #sc.hmean(l), stat.median(l), min(l), max(l), stat.pstdev(l, mu), stat.pvariance(l, mu))
def con_test(stat_list, player, stat_name): # Computes actual data points from data given via consist_test if stat_list: con_stat = (mean(stat_list), pvariance(stat_list), pstdev(stat_list)) return con_stat else: print('NO DATA FOR: '+player+', '+stat_name) return 0
def lpd(count_data, R): """ Compute lpd values of the 2 models, keep its difference, its standard deviation and the location of the change point found. """ N = len(count_data) #number of points prs = max(count_data) + 10 # prior took high nc = 6 # number of processor put high #compute lpd value of the no change model lpd_poisson = np.zeros(N) # list of lpd values of points model_poisson_loo = stan_utility.compile_model('STAN/poisson_loo.stan') for n in range(N): #iterate d_loo = count_data[n] #point removed d = np.array([count_data[i] for i in range(N) if i != n]) #rest of data fit_data = {"N": N, "d": d, "prs": prs, "d_loo": d_loo, "n_loo": n} fit_nocp_loo = model_poisson_loo.sampling(data=fit_data, iter=R, chains=nc, seed=4838282, refresh=0) #4000 fits lpd_poisson[n] = logsumexp(fit_nocp_loo["log_lik_d_loo"]) - np.log( len(fit_nocp_loo["log_lik_d_loo"])) loonochange = np.sum(lpd_poisson) # total lpd value of the model # compute lpd value of the change point model lpd_poisson_cp = np.zeros(N) # list of lpd values of points model_poisson_loo_cp = stan_utility.compile_model( 'STAN/poisson_cp_loo.stan') for n in range(N): #iterate d_loo = count_data[n] #point removed d = np.array([count_data[i] for i in range(N) if i != n]) #rest of data fit_data = { "N": N, "d": d, "pes": prs, "pls": prs, "d_loo": d_loo, "n_loo": n } fit_cp_loo = model_poisson_loo_cp.sampling(data=fit_data, iter=R, chains=nc, seed=4838282, refresh=0) lpd_poisson_cp[n] = logsumexp(fit_cp_loo["log_lik_d_loo"]) - np.log( len(fit_cp_loo["log_lik_d_loo"])) loochange = np.sum(lpd_poisson_cp) # total lpd value of the model #compute standard deviation of the difference of lpd values diff = lpd_poisson_cp - lpd_poisson sigma = np.sqrt(N * st.pvariance(diff)) #look for change point location cpdistrib = cpsearch(count_data, R) cp = np.argmax(cpdistrib) return ( loochange - loonochange, sigma, cp ) #lpd value difference, its standard deviation, and change point location
def stats_plot_2d_graph(x_label, y_label, x_cordinate_data = [],y_cordinate_data = []): #map(float,x_cordinate_data) #map(float,y_cordinate_data) x_range_values = [] y_range_values = [] j=0 for i in range (len (x_cordinate_data)): if i == 0: print "skipping for error round off" else: x_range_values.insert(j,float(x_cordinate_data[i])) y_range_values.insert(j,float(y_cordinate_data[i])) j=j.__int__()+1 mean_x = mean(x_range_values) mean_y = mean(y_range_values) median_x = median(x_range_values) median_y = median(y_range_values) median_group_x = statistics.median_grouped(x_range_values) median_group_y = statistics.median_grouped(y_range_values) print x_range_values print y_range_values p_variance_value_x = statistics.pvariance(x_range_values) p_variance_value_y = statistics.pvariance(y_range_values) xlabel(x_label) ylabel(y_label) plot(x_range_values,y_range_values,'ro') text(mean_x,mean_y,"<-- That's the mean value of x and y") text(median_group_x,median_group_y,"<-- Median Group value of x and y after interpolation") x_range_values.sort() y_range_values.sort() x_range_values.reverse() y_range_values.reverse() value_for_graph_info_xlabels = x_range_values[0] - 2 value_for_graph_info_ylabels = y_range_values[0] + 2 text(value_for_graph_info_xlabels,value_for_graph_info_ylabels,"Pvariance_x --> %.3d"% p_variance_value_x) value_for_graph_info_ylabels = value_for_graph_info_ylabels - 1 text(value_for_graph_info_xlabels,value_for_graph_info_ylabels,"Pvariance_y --> %.3d"% p_variance_value_y) value_for_graph_info_ylabels = value_for_graph_info_ylabels + 2 text(value_for_graph_info_xlabels,value_for_graph_info_ylabels,"Mean_x --> %.3d"% mean_x) value_for_graph_info_ylabels = value_for_graph_info_ylabels + 1 text(value_for_graph_info_xlabels,value_for_graph_info_ylabels,"Mean_y --> %.3d"% mean_y) show()
def train_neutral(self, time): """8 seconds""" j=self.a.get_with_settings(["FC5", "F3", "F4", "FC6"], ["Beta", "Mu"]) start, end=time for i in ["FC5", "F3", "F4", "FC6"]: for b in [2, 3]: self.neures[i][b].append(statistics.mean(j[i][b][(start-4)*8:(end-4)*8])) self.neures[i][b].append(statistics.stdev(j[i][b][(start-4)*8:(end-4)*8])) self.neures[i][b].append(statistics.pvariance(j[i][b][(start-4)*8:(end-4)*8])) self.neureseq[i][b].append(self.__get_with_resolution(self.DEFAULT_NUMBER, j[i][b][(start-4)*8:(end-4)*8], 1))
def web_dataset_reader(url): ''' :param url: Input a web address. :return: This algorithm returns a dataseet and its descriptive statistics. Example: >>> url='http://robjhyndman.com/tsdldata/ecology1/hopedale.dat' >>> import web_dataset_reader_program as wbd >>> print(wbd.web_dataset_reader(url)) >>> . . . ''' from urllib import request as ur import web_skip_header_program as wh import statistics as st highvalue=0 count=0 with ur.urlopen(url) as webpage: first_data=wh.webpage_skip_head(webpage) first_data=first_data.split() dataset=first_data for data in webpage: # This reads the remaining lines of the webpage data=data.decode('utf-8') data=data.split() dataset+=data # For each iteration, the data transformed into # list append to dataset with first_data as its first list # #print(dataset) data_float=dataset for i in range(len(dataset)): data=float(dataset[i]) data_float[i]=float(dataset[i]) # Elements in the list 'dataset' are transformed to # float for additional operations such as min, max, range, sum count+= 1 # This counts the number of elements in the list highvalue =max(highvalue,data) # Zero is assigned to highvalue for its start value. # The data changes for each loop and compared with each element in the list lowvalue = min(data_float) totalvalue =sum(data_float) rangevalue = highvalue - lowvalue #print(count) observation=len(dataset) average=totalvalue/observation mean=st.mean(data_float) median=st.median(data_float) median_high=st.median_high(data_float) median_low=st.median_low(data_float) #mode=st.mode(data_float)# If there is more than one mode, it will return Stat Error stdev=st.pstdev(data_float) variance=st.pvariance(data_float) return print('The Dataset in List form is:\n',data_float,'\n', '=============================================\n',' DIAGNOSTIC ANALYTICS \n', '=============================================\n','The Descriptive Statistics of the Dataset are:', '\nTotal:\t\t{3}\nMaximum:\t{0}\nMinimum:\t{1}\nRange:\t\t{2}\nAverage:\t{5:.2f}\nMedian:\t\t{6}' '\nMedianHigh:\t{7}\nMedian Low:\t{8}\nVariance:\t{10:.2f}\nStd.Dev:\t{9:.2f}\nCounts:\t\t{4}' .format(highvalue,lowvalue,rangevalue,totalvalue,observation,mean,median,median_high, median_low,stdev,variance),'\n','=============================================')
def setData(x,y): #进行数据处理 xdata={'avg':None,'stdev':None,'pstdev':None,'var':None,'pvar':None} ydata={'avg':None,'stdev':None,'pstdev':None,'var':None,'pvar':None} xdata['avg']=round(mean(x),3) ydata['avg']=round(mean(y),3) xdata['stdev']=round(stdev(x),3) ydata['stdev']=round(stdev(y),3) xdata['pstdev']=round(pstdev(x),3) ydata['pstdev']=round(pstdev(y),3) xdata['var']=round(variance(x),3) ydata['var']=round(variance(y),3) xdata['pvar']=round(pvariance(x),3) ydata['pvar']=round(pvariance(y),3) return xdata,ydata
def main(num_nodes, packet_size, random_ranges, attempts, sim_time): # keep track of utilization num_idle = 0 num_collisions = 0 # set Node class variables Node.max_attempts = attempts Node.random_ranges = random_ranges # create nodes all_nodes = [] for _ in range(num_nodes): all_nodes.append(Node()) # simulate clock = 0 while clock < sim_time: # check if any nodes that can transmit now. ready_to_transmit = [] for a_node in all_nodes: if a_node.can_transmit(): ready_to_transmit.append(a_node) # transmit if only 1 node needs to if len(ready_to_transmit) == 1: ready_to_transmit.pop().send_packet() clock += packet_size continue # collisions if len(ready_to_transmit) > 1: num_collisions += 1 for colliding_node in ready_to_transmit: colliding_node.collision() # idle channel else: num_idle += 1 for a_node in all_nodes: a_node.tick() clock += 1 utilization = (sim_time - num_collisions - num_idle) / sim_time * 100 percent_idle = (num_idle / sim_time) * 100 variance_success = statistics.pvariance([a_node.num_transmits for a_node in all_nodes]) variance_collisions = statistics.pvariance([a_node.num_collisions for a_node in all_nodes]) return utilization, percent_idle, num_collisions, variance_success, variance_collisions
def learning_variance(self, path=ALL_PATHS): """Computes the variance of the students' learning gain :param path: if specified, restricts the computation to student that have followed this specific json path :return: variance of the students' learning gain """ progress_list = self.progress_data(path=path) if progress_list: return round(pvariance(progress_list), 4) else: return "N/A"
def zero_mean_variance(Y, Y_pred): y, y_pred = removenans(Y, Y_pred) Deviation = math.sqrt(statistics.pvariance(y)) Mean = statistics.mean(y) # print("Mean=={0}, Deviation=={1}".format(Mean,Deviation)) Y = np.array(Y) Y_pred = np.array(Y_pred) # return y, y_pred return (Y - Mean)/Deviation, (Y_pred - Mean)/Deviation
def setData(x,y): xsta={'avg':None,'stdev':None,'pstdev':None,'var':None,'pvar':None} #x的数据处理,将各个数放入字典中 ysta={'avg':None,'stdev':None,'pstdev':None,'var':None,'pvar':None} #y的数据处理,将各个数放入字典中 xsta['avg']=mean(x) #x平均数 ysta['avg']=mean(y) #y平均数 xsta['stdev']=stdev(x) #x标准差 ysta['stdev']=stdev(y) #y标准差 xsta['pstdev']=pstdev(x) #x样本总体的标准偏差 ysta['pstdev']=pstdev(y) #x样本总体的标准偏差 xsta['var']=variance(x) #x方差 ysta['var']=variance(y) #y方差 xsta['pvar']=pvariance(x) #x样本总体的方差 ysta['pvar']=pvariance(y) #y样本总体的方差 return xsta,ysta #返回各数
def satData(x ,y): #求x、y的均值标准差和方差 xsta={'avg':None,'stdev':None,'pstdev':None,'var':None,'pvar':None} ysta={'avg':None,'stdev':None,'pstdev':None,'var':None,'pvar':None} xsta['avg']=mean(x) ysta['avg']=mean(y) xsta['stdev']=stdev(x) ysta['stdev']=stdev(y) xsta['pstdev']=pstdev(x) ysta['pstdev']=pstdev(y) xsta['var']=variance(x) ysta['var']=variance(y) xsta['pvar']=pvariance(x) ysta['pvar']=pvariance(y) r=np.corrcoef(x,y)[0, 1] return xsta,ysta,r
def variance_signal (file_name) : data = [] file = open (file_name, 'rb') byte = file.read(1) while str(byte) != "b''" : #print ("\nAAAAAA: " + str(byte)) data.append(ord(byte)) #print ("\nBBBBBB: " + str(data[len(data)-1])) byte = file.read(1) file.close() return statistics.pvariance(data)
def satData(x,y): xsta={'avg':None,'stdev':None,'pstdev':None,'var':None,'pvar':None} #x的数据处理,将各个数放入字典中 ysta={'avg':None,'stdev':None,'pstdev':None,'var':None,'pvar':None} #y的数据处理,将各个数放入字典中 xsta['avg']=mean(x) #x平均数 ysta['avg']=mean(y) #y平均数 xsta['stdev']=stdev(x) #x标准差 ysta['stdev']=stdev(y) #y标准差 xsta['pstdev']=pstdev(x) #x样本总体的标准偏差 ysta['pstdev']=pstdev(y) #x样本总体的标准偏差 xsta['var']=variance(x) #x方差 ysta['var']=variance(y) #y方差 xsta['pvar']=pvariance(x) #x样本总体的方差 ysta['pvar']=pvariance(y) #y样本总体的方差 r=np.corrcoef(x,y)[0, 1] #x、y的相关性系数 return xsta,ysta,r #返回各数
def main(): print(stats.mean(range(6))) print(stats.median(range(6))) print(stats.median_low(range(6))) print(stats.median_high(range(6))) print(stats.median_grouped(range(6))) try: print(stats.mode(range(6))) except Exception as e: print(e) print(stats.mode(list(range(6)) + [3])) print(stats.pstdev(list(range(6)) + [3])) print(stats.stdev(list(range(6)) + [3])) print(stats.pvariance(list(range(6)) + [3])) print(stats.variance(list(range(6)) + [3]))
def staData(x, y): # 定义一个函数统计数据 xsta = {'avg': None, 'stdev': None, 'pstdev': None, 'var': None, 'pvar': None} # 定义一个字典来存放x轴数据的统计结果 ysta = {'avg': None, 'stdev': None, 'pstdev': None, 'var': None, 'pvar': None} # 定义一个字典来存放y轴数据的统计结果 xsta['avg'] = mean(x) ysta['avg'] = mean(y) xsta['stdev'] = stdev(x) ysta['stdev'] = stdev(y) xsta['pstdev'] = pstdev(x) ysta['pstdev'] = pstdev(y) xsta['var'] = variance(x) ysta['var'] = variance(y) xsta['pvar'] = pvariance(x) ysta['pvar'] = pvariance(y) # 调用已从statistics模块导入的函数对数据进行统计 r = np.corrcoef(x, y)[0, 1] # 调用函数计算相关系数,但显示numpy模块中没有此函数 return xsta, ysta, r
def probability_metric_cluster(G, members): """ Given the members of a cluster and the graph they belong to, finds the cluster's mean, standard deviation, and variance. Note: n currently defaults to the number of members in the community. TODO: testing, to find out whether this is a legitimate normalization. """ nMembers = len(members) # figure out if this is a good normalization # numVertices = G.vcount(); # normalization = nMembers / numVertices data = [p_in_after_n(G, v, nMembers, members) for v in members] mean = statistics.mean(data) # could divide mean by normalization var = statistics.pvariance(data, mu=mean) return mean, var
def calculate(index, title, config, datafolder): filename = os.path.join(datafolder, 'data%i.csv' % index) with open(filename, 'r') as csvFile: reader = csv.reader(csvFile, delimiter=',') re = dict() for rowindex, row in enumerate(reader): if rowindex: for t in range(3): if row[t*2]: li = re.setdefault(t, list()) if float(row[t*2]) > 5000: li.append(float(row[t*2+1])) with open('%s.tex' % filename[:-4], '+a') as texfile: texfile.write('\\def\\variance{{%s}}%%\n' % ', '.join([ '"%s"' % round(statistics.pvariance(re[i]), 3) for i in range(3)])) texfile.write('\\def\\median{{%s}}%%\n' % ', '.join([ '"%s"' % round(statistics.median(re[i]), 3) for i in range(3)])) texfile.write('\\def\\average{{%s}}%%\n' % ', '.join([ '"%s"' % round(statistics.mean(re[i]), 3) for i in range(3)])) texfile.write('\\def\\benchmark{%s}%%\n' % save_latex(title)) texfile.write('\\def\\description{%s}%%\n' % save_latex(config['desc'])) exectimes = None with open('%s.tex' % filename[:-4], 'r') as texfile: for line in texfile: linematch = REGEX_TIME.match(line) if linematch: exectimes = linematch.groups() exectimes = [float(i) for i in exectimes] medt = statistics.median(exectimes) medbm = statistics.median(sum(re.values(),[])) data = dict(pos=str(index + 1), name=title, bm1=round(statistics.median(re[0]), 1), bm2=round(statistics.median(re[1]), 1), bm3=round(statistics.median(re[2]), 1), t1=round(exectimes[0], 0), t2=round(exectimes[1], 0), t3=round(exectimes[2], 0), medbm=medbm, medt=medt, power=None, energy=None ) return data
def get_stats_images_tags(): query = 'SELECT tag.TagId, tag.TagName, COUNT(image.ImageId) AS [NumImages],' \ ' (COUNT(tag.TagId) * 1.0/' \ ' (SELECT COUNT(*) FROM tag INNER JOIN images_tags ON tag.TagId = images_tags.TagId)' \ ' ) * 100 AS Percentage' \ ' FROM tag' \ ' INNER JOIN images_tags ON tag.TagId = images_tags.TagId' \ ' INNER JOIN image ON images_tags.ImageId = image.ImageId' \ ' GROUP BY tag.TagId' \ ' ORDER BY NumImages DESC, tag.TagName' result = engine.execute(query) counts = [] tags = [] max = 0 for row in result: if max < 25: t = TagStat() t.TagId = row[0] t.TagName = row[1] t.Images = row[2] t.Percentage = row[3] tags.append(t) counts.append(int(row[2])) max += 1 stats = TagStats() if max > 0: stats.Average = statistics.mean(counts) stats.Median = statistics.median(counts) try: stats.Mode = statistics.mode(counts) except statistics.StatisticsError: stats.Mode = 'N/A' stats.StdDev = statistics.pstdev(counts) stats.Variance = statistics.pvariance(counts) stats.Lower = stats.Average - (2 * stats.StdDev) stats.Higher = stats.Average + (2 * stats.StdDev) stats.TopTags = tags return stats
def NormDistrib(arr, bins): bins = 12 mu = st.mean(arr) D = st.pvariance(arr) arr = sorted(arr) fit = stats.norm.pdf(arr, mu, sqrt(D)) t1, t2, t3 = hist(arr, bins, normed=True, label='mu = ' + str(mu)) plot(arr, fit, 'r', lw=3, label='variance = ' + str(D)) legend() print(t1) print(t2) show()
def get_stats_images_people(): query = 'SELECT images_people.PersonId, COUNT(image.ImageId) AS [NumImages]' \ ' FROM image' \ ' INNER JOIN images_people ON image.ImageId = images_people.ImageId' \ ' INNER JOIN person ON images_people.PersonId = person.PersonId' \ ' GROUP BY images_people.PersonId' \ ' ORDER BY NumImages DESC, person.Name' result = engine.execute(query) counts = [] people = [] max = 0 for row in result: if max < 25: p = PeopleStats() rp = session.query(Person).get(int(row[0])) p.PersonId = rp.PersonId p.Name = rp.Name p.Images = (int(row[1])) p.Percentage = Stats.get_images_with_person_percent(int(row[0])) people.append(p) counts.append(int(row[1])) max += 1 stats = ImageStats() if max > 0: stats.Average = statistics.mean(counts) stats.Median = statistics.median(counts) try: stats.Mode = statistics.mode(counts) except statistics.StatisticsError: stats.Mode = 'N/A' stats.StdDev = statistics.pstdev(counts) stats.Variance = statistics.pvariance(counts) stats.Lower = stats.Average - (2 * stats.StdDev) stats.Higher = stats.Average + (2 * stats.StdDev) stats.TopPeople = people return stats
def variancia_freq(N, p0, G, iteracoes): lista_frequencias = [] freq_na_geracao = [] #de uso temporario, armazena todos as frequencias para uma mesma geracao numa lista variancia = [] i = 0 while ( i < iteracoes): lista_frequencias.append(genetic_drift(N, p0, G)) i+=1 i=0 while(i< G): j=0 freq_na_geracao = [] #limpa lista while (j < iteracoes): freq_na_geracao.append(lista_frequencias[j][i]) #faz lista iiiiiiiiiiii j+=1 variancia.append( statistics.pvariance(freq_na_geracao) ) #adiciona numa lista a variancia de cada geracao i+=1 return variancia
def pvariance(self): return statistics.pvariance(self.price)
#!/usr/bin/env python3 import sys import statistics lines = sys.stdin.read().splitlines() chroms = [x.split()[0] for x in lines] distance_estimations = [float(x.split()[1]) for x in lines[:-1]] positions = [int(x.strip('chrA1.')) for x in chroms] distances = [a - b for a, b in zip(positions, positions[1:])] assert len(distances) == len(distance_estimations) ks = [int(d / est) for (d, est) in zip(distances, distance_estimations) if est > 0] print(statistics.pvariance(ks))
import sa, statistics if __name__ == "__main__": assemblies = sa.load_all() neighbourhood_freq = [len(piece.neighbourhood) for ass in assemblies for _, piece in ass.pieces.items()] print('Average neighbourhood size per piece per mix:', sum(neighbourhood_freq)/len(neighbourhood_freq)) pvariance = statistics.pvariance(neighbourhood_freq) print('Variance in neighbourhood size: ' + str(round(pvariance, 2)))
import sa, statistics if __name__ == "__main__": assemblies = sa.load_all() marker_total = [] found_marker_total = [] piece_total = [] found_piece_total = [] for assembly in assemblies: marker_total.append(assembly.total_markers + assembly.found_markers) found_marker_total.append(assembly.found_markers) piece_total.append(assembly.total_pieces) found_piece_total.append(assembly.found_pieces) pavg = statistics.mean(found_piece_total)/piece_total[0] print('Found pieces: ' + str(sum(found_piece_total)) + '/' + str(sum(piece_total)) \ + ' (' + str(round(pavg*100, 2)) + '%)') pvariance = statistics.pvariance(found_piece_total) print('Variance in no. found pieces: ' + str(round(pvariance, 2))) mavg = statistics.mean(found_marker_total)/marker_total[0] print('Found markers: ' + str(sum(found_marker_total)) + '/' + str(sum(marker_total)) \ + ' (' + str(round(mavg*100, 2)) + '%)') mvariance = statistics.variance(found_marker_total, mavg*marker_total[0]) print('Variance in no. found markers: ' + str(mvariance)) print(found_marker_total)
def pvariance(self): '返回DataStruct.price的方差 variance' return self.price.groupby('code').apply(lambda x: statistics.pvariance(x))
def cpvariance(self): if hasattr(self, '_pvariance') and self._pvariance: return self._pvariance self._pvariance = pvariance(self._values) return self._pvariance
def _position_cost_variance(pos, history): history = BPHungarianDrawGenerator._update_history(pos, history) return pvariance(history)
print("even data set low median =",statistics.median_low([1,3,5,7])) #Median high: when the number of points in the data set is odd, this function will return the middle value. When the number of data points #is even, it will return the highest of the two middle points. print("data high median =",statistics.median_high(data)) #Example with a dataset with even number of data points: print("even data set high median =",statistics.median_high([1,3,5,7])) #MEASURES OF SPREAD: #Sample standard deviation print("data standard deviation =", statistics.stdev(data)) #Variance print("data variance =",statistics.variance(data)) #There is also another measurement of standard deviation, the population standard deviation: print("data population standard deviation = ",statistics.pstdev(data,mu=None)) #And the population variance of data. In this function there is also the argument mu, that corresponds to the mean of data. If mu is #not assigned or is 'None', than the men is also calculated by this function. print("data population variance = ",statistics.pvariance(data)) #Taken from: Documentation » The Python Standard Library » 9. Numeric and Mathematical Modules » 9.7. statistics — Mathematical statistics functions #https://docs.python.org/3/library/statistics.html # In[ ]: