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[ ]:
