def mann_white(venom_vals_list,others_gp_vals):
'''compares one mean to another are they signif different
takes a two list of floats for each group
Mann-... U test for significant difference between
two groups\
>>>
>>>mann_white(list_venom_dnds_as_floats,list_comparable_gp_vals)
...Mean venom dnds = 0.470993103448, mean others 0.292471404883.
...Mann-whitney test U = 205437.0 with a p(one tailed) = 2.42740449563e-06
>>>
One-sided p-value assuming a asymptotic normal distribution.
Notes
Use only when the number of observation in each sample is > 20 and
you have 2 independent samples of ranks. Mann-Whitney U is significant
if the u-obtained is LESS THAN or equal to the critical value of U.
This test corrects for ties and by default uses a continuity correction
. The reported p-value is for a one-sided hypothesis, to get the two-sided
p-value multiply the returned p-value by 2.'''
test_gp = [vals for vals in venom_vals_list] #redundent but helps understanding
other_gp = [vals for vals in others_gp_vals]
result = stats.mannwhitneyu(test_gp,other_gp)
test_mean = stats.mean(test_gp)
other_mean = stats.mean(other_gp)
return "Mean venom dnds = %s, mean others %s.Mann-whitney test U = %s with a p(one tailed) = %s"\
%(test_mean,other_mean,result[0],result[1])
def get_mean_times(data, buildtype, include_outliers):
return_data = defaultdict(lambda: defaultdict(float))
all_times = reduce(lambda x,y: x+y, reduce(lambda x,y: x+y, map(lambda d: d.values(), data.values())))
overall_mean = stats.mean(all_times)
overall_stdev = stats.stdev(all_times)
for (date, dateval) in data.iteritems():
typedict = {}
for (type, times) in dateval.iteritems():
mean = stats.mean(times)
if not include_outliers and len(times) > 1:
included_values = []
for time in times:
if abs(time - overall_mean) < 1.5*overall_stdev:
included_values.append(time)
if len(included_values) > 0:
mean = stats.mean(included_values)
else:
mean = None
typedict[type] = mean
if buildtype == "maximum" and max(typedict.values()):
return_data[date] = max(typedict.values())
elif typedict.get(buildtype):
return_data[date] = typedict.get(buildtype, 0)
return return_data
def stats(self):
res = {}
for val in self.data.iteritems():
stat_report = {}
full_series = map(lambda x: x, val[1])
full_series = full_series[(len(full_series) / 4):] # Cut off first quarter to get more reliable data
full_series_sorted = full_series
full_series_sorted.sort()
steady_series = full_series[int(len(full_series) * 0.7):]
stat_report['mean'] = stats.mean(full_series)
try:
stat_report['stdev'] = stats.stdev(full_series)
except ZeroDivisionError:
stat_report['stdev'] = 0
stat_report['upper_0.1_percentile'] = self.percentile(full_series_sorted, 0.999)
stat_report['lower_0.1_percentile'] = self.percentile(full_series_sorted, 0.001)
stat_report['upper_1_percentile'] = self.percentile(full_series_sorted, 0.99)
stat_report['lower_1_percentile'] = self.percentile(full_series_sorted, 0.01)
stat_report['upper_5_percentile'] = self.percentile(full_series_sorted, 0.95)
stat_report['lower_5_percentile'] = self.percentile(full_series_sorted, 0.05)
stat_report['steady_mean'] = stats.mean(steady_series)
try:
stat_report['steady_stdev'] = stats.stdev(full_series)
except ZeroDivisionError:
stat_report['steady_stdev'] = 0
res[val[0]] = stat_report
return res
def main():
if len(sys.argv) < 3:
print "Usage!"
exit(1)
database = sys.argv[2]
points = sys.argv[1]
boxData = csv.reader(open(points, "rb"))
boxes = []
for row in boxData:
if len(row) == 4:
boxes.append({"time": long(row[0]), "size": float(row[1]), "position": (int(row[2]), int(row[3]))})
else:
finishTime = long(row[0].split(":")[1])
conn = sqlite3.connect(database)
cur = conn.cursor()
cur.execute(
'select datetime,data from clues where kind="touch" and datetime between %d and %d'
% (boxes[0]["time"], finishTime)
)
touches = []
for touch in cur:
time = long(touch[0])
data = touch[1].split(",")
touches.append({"time": long(touch[0]), "position": (int(data[0]), int(data[1])), "pressure": float(data[2])})
timesForSize = {30: [], 60: [], 99: [], 129: []}
mmsizes = {30: 3, 60: 6, 99: 10, 129: 13}
deltas = []
for i, box in enumerate(boxes[:-1]):
delta = (boxes[i + 1]["time"] - box["time"]) / 1000.0
timesForSize[box["size"]].append(delta)
deltas.append(delta)
deltas.append((finishTime - boxes[-1]["time"]) / 1000.0)
for k, v in sorted(timesForSize.iteritems()):
print "%d: %.3f/%.3f/%.3f/%.3f (%.3f bps)" % (
mmsizes[k],
stats.mean(v),
min(v),
max(v),
stats.stdev(v),
1 / stats.mean(v),
)
def set_quality_mean_and_variation_per_position(self):
self.read_all_quality_strings_by_position()
self.means = [mean(self.quality_string2score(s)) for s in self.quality_strings]
self.stdevs = [stdev(self.quality_string2score(s)) for s in self.quality_strings]
# relase the memory for quality_strings
self.quality_strings = None
def adc_var ( ip_addr, ip_port, timeout, channel, packetNumber, buffer_size, verbose):
s_adc = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
s_adc.settimeout( int(timeout) )
# try connection
try:
s_adc.connect( (ip_addr, int( ip_port ) ) )
except:
print "adc_var(): Error, no ADC connection, port: ", ip_port,
s_adc.close()
sys.exit()
# open connection
message = sendReceive ( s_adc, channel, packetNumber,
buffer_size, verbose )
# close connection
s_adc.close()
# unpacking message
msg_len = len(message)
if msg_len > 0:
num = unpack(str(msg_len)+'B', message)
# add offset, [0 255] -> [-128 128]
num = map(lambda x: x-128, num)
if verbose:
print "Min=", min(num), "Max=", max(num), "Mean=", stats.mean(num), "Var=", stats.var(num), "Std=", stats.stdev(num)
var = stats.var(num)
else:
var = "N/A"
return var
def main():
global qtimes,qerr
reps = int(sys.argv[1])
for j in range(reps):
jobs = [gevent.spawn(get_url, url) for url in urls]
#print("Size of jobs is {n}".format(n=len(jobs)))
gevent.joinall(jobs, timeout=30)
if not qerr.empty():
qerr.put(StopIteration)
for err in qerr:
print(err)
print("jobs size {s}".format(s=len(jobs)))
print("qstart size {n}".format(n=qstart.qsize()))
print("qtimes size {n}".format(n=qtimes.qsize()))
qtimes.put(StopIteration)
times = []
for item in qtimes:
times.append(item)
print("Min {t}".format(t=min(times)))
print("Max {t}".format(t=max(times)))
print("Mean {t}".format(t=stats.mean(times)))
print("StdDev {t}".format(t=stats.stdev(times)))
def main():
'''
this is the main section
{kernel: {machine : {[results]} } }
'''
scales = {}
data = send(template())
for kernel, results in data.iteritems():
for testid, run_data in results.iteritems():
machine = run_data.pop(0)
print "\n%s" % (kernel,)
for i in range(len(run_data)):
for single_bench in run_data[i].itervalues():
if type(single_bench) == dict:
value = [float(x) for x in
single_bench.get("RawString").split(":")]
val = stats.mean(value)
if len(value) > 1:
std = stats.stdev(value)
else:
std = float(0)
name = single_bench.get("Name")
attr = single_bench.get("Attributes")
scale = single_bench.get("Scale")
print "%s: %s (%s): %.2f %s (std %.2f)" % (machine,
name, attr, val, scale, std)
scales[scale] = scales.get(scale, "")
print scales
def main():
(opts, args) = parser.parse_args()
if len(args) != 1:
print "\nPlease, select channel: 0/1\n"
parser.print_help()
else:
if opts.verbose:
verbose = True
print "connecting to ", opts.ip_addr
print "port number", opts.ip_port
message = args[0]
message = sendReceive(opts.ip_addr, opts.ip_port, opts.timeout,
message, opts.verbose)
#print "String:"
#print message
#print "Hex:"
hexMessage = b2a_hex(message)
#print hexMessage
print "No. bytes: ", len(message)
print "Done!"
#Unpacking message
msg_len = len(message)
num = unpack(str(msg_len) + 'B', message)
#print num
num = map(lambda x: x - 128, num)
#print num
print "Maximum: ", max(num), "Minimum: ", min(
num), "Mean: ", stats.mean(
num), "Standard deviation: ", stats.stdev(
num), "Variance: ", stats.var(num)
def means(serieses):
res = []
for series in serieses:
try:
res.append(stats.mean(map(lambda x: x, series)))
except ZeroDivisionError:
res.append(0.0)
return res
def means(serieses):
res = []
for series in serieses:
try:
res.append(stats.mean(map(lambda x: x, series)))
except ZeroDivisionError:
res.append(0.0)
return res
def parseResultsFile(filename):
resultsFile = open(filename, 'r')
contents = resultsFile.read()
columns = contents.split("\n")[0].split(',')
data = {}
for value in columns:
data[value] = []
lines = contents.split("\n")
if len(lines) <= 1:
return None
for i in range(1, len(lines)):
items = lines[i].split(', ')
for i in range(len(items)):
data[columns[i]].append(items[i])
trials = str(len(data[data.keys()[0]]))
for key in data:
if key == 'accuracy':
meanAccuracy = 0
statList = [] #kld
for i in range(len(data[key])):
#print data[key][i]
data[key][i] = float(data[key][i])
meanAccuracy += data[key][i]
statList.append(data[key][i]) #kld
meanAccuracy /= len(data[key])
meanAccuracy = '%.1f' % round(meanAccuracy, 1)
#print statList
#print numpy.mean(statList)
#print numpy.std(statList)
elif key == 'overhead':
numeratorSum = 0
denominatorSum = 0
for i in range(len(data[key])):
value = data[key][i].split('/')
numeratorSum += int(value[0])
denominatorSum += int(value[1])
overhead = str(
round((numeratorSum * 100.0 / denominatorSum) - 100, 1))
elif key == 'timeElapsedTotal':
for i in range(len(data[key])):
data[key][i] = float(data[key][i])
timeElapsed = str(round(stats.mean(data[key]), 1))
return [
meanAccuracy, overhead, timeElapsed, trials,
numpy.mean(statList),
numpy.std(statList)
]
def histogram(self, out_fname, large = False):
assert self.data
# Hacky workaround in the case that a run had no data.
for x in self.data.values():
if len(x) == 0: x.extend([0,0])
if not large:
font = fm.FontProperties(family=['sans-serif'],size='small',fname=FONT_FILE)
mpl.rcParams['xtick.major.pad'] = 4
mpl.rcParams['ytick.major.pad'] = 4
mpl.rcParams['lines.linewidth'] = 1
else:
font = fm.FontProperties(family=['sans-serif'],size=36,fname=FONT_FILE)
mpl.rcParams['xtick.major.pad'] = 20
mpl.rcParams['ytick.major.pad'] = 20
mpl.rcParams['lines.linewidth'] = 5
fig = plt.figure()
# Set the margins for the plot to ensure a minimum of whitespace
ax = plt.axes([0.12,0.12,0.85,0.85])
data = map(lambda x: x[1], self.data.iteritems())
mean = stats.mean(map(lambda x: x, reduce(lambda x, y: x + y, data)))
stdev = stats.stdev(map(lambda x: x, reduce(lambda x, y: x + y, data)))
labels = []
hists = []
for series, color in zip(self.data.iteritems(), colors):
clipped_data = clip(series[1], 0, 3 * mean)
if clipped_data:
_, _, foo = ax.hist(clipped_data, bins=200, histtype='bar', facecolor = color, alpha = .5, label = series[0])
hists.append(foo)
labels.append(series[0])
else:
print "Tried to make a histogram of a series of size 0"
for tick in ax.xaxis.get_major_ticks():
tick.label1.set_fontproperties(font)
for tick in ax.yaxis.get_major_ticks():
tick.label1.set_fontproperties(font)
ax.set_ylabel('Frequency', fontproperties = font)
ax.set_xlabel('Latency (microseconds)', fontproperties = font) #simply should not be hardcoded but we want nice pictures now
ax.grid(True)
# Dirty hack to get around legend miscoloring: drop all the hists generated into the legend one by one
if hists:
plt.legend(map(lambda x: x[0], hists), labels, loc=1, prop = font)
if not large:
fig.set_size_inches(5,3.7)
fig.set_dpi(90)
plt.savefig(out_fname, bbox_inches="tight")
else:
ax.yaxis.LABELPAD = 40
ax.xaxis.LABELPAD = 40
fig.set_size_inches(20,14.8)
fig.set_dpi(300)
plt.savefig(out_fname, bbox_inches="tight")
def weighSample():
listOfValues = []
weight = float(0.0)
count = 0
kcount = 0
averageWeight = 0.0
stdevWeight = 0.0
statustext = "Weighing sample"
STATUS.set(statustext)
statusWindow.update()
a = []
ACOUNT.set(0)
MCOUNT.set(0)
AVERAGEWEIGHT.set(0.0)
STDDEVWEIGHT.set(0.0)
STATUS.set("")
statusWindow.update()
weightArray = []
stopCheck = STOPPED.get()
averageWeight = 0.0
stdevWeight = 0.0
while STOPPED.get() < 1:
statusWindow.update()
result = []
weight = readStandardBalance()
#print "WEIGHT: ", weight
ACOUNT.set(ACOUNT.get() + 1)
statusWindow.update()
if weight is FALSE:
pass
elif weight > 0.0:
count += 1
weightArray.append(weight)
if (STOPPED.get() < 1 ):
if count > 4:
averageWeight = stats.mean(weightArray)
stdevWeight = stats.stdev(weightArray)
MCOUNT.set(count)
if count < 5:
statustext = " Count: %d the average weight of sample is <need at least 5 measurements>" % (count)
else:
statustext = "Count: %d the average weight of sample is: %f with stdev of: %f" % (
count, averageWeight, stdevWeight)
STATUS.set(statustext)
AVERAGEWEIGHT.set(averageWeight)
STDDEVWEIGHT.set(stdevWeight)
statusWindow.update()
stopCheck = STOPPED.get()
else:
is_there_a_sample()
sleep(1)
NEXTSTEP.set(1)
AVERAGEWEIGHT.set(averageWeight)
STDDEVWEIGHT.set(stdevWeight)
MCOUNT.set(count)
return count, averageWeight, stdevWeight
def set_quality_mean_and_variation_per_position(self):
self.read_all_quality_strings_by_position()
self.means = [mean(self.quality_string2score(s))
for s in self.quality_strings]
self.stdevs = [stdev(self.quality_string2score(s))
for s in self.quality_strings]
# relase the memory for quality_strings
self.quality_strings = None
def main():
if (len(sys.argv) < 3):
print "Usage!"
exit(1)
database = sys.argv[2]
points = sys.argv[1]
boxData = list(csv.reader(open(points, 'rb')))
boxes = [{"time":long(row[0]), "size":float(row[1]), "position":(int(row[2]),int(row[3]))} for row in boxData[:-1]]
finishTime = long(boxData[-1][0].split(':')[1])
conn = sqlite3.connect(database)
cur = conn.cursor()
cur.execute('select datetime,data from clues where kind="touch" and datetime between %d and %d' % (boxes[0]['time'],finishTime))
touches = [{'time':long(t[0]), 'position':(int(t[1].split(',')[0]), int(t[1].split(',')[1])), 'pressure':float(t[1].split(',')[2])} for t in cur]
boxesWithTouches = []
for i,box in enumerate(boxes[:-1]):
time = box['time']
nextTime = boxes[i+1]['time']
def f(x): return x['time'] > time and x['time'] < nextTime
associatedTouches = filter(f, touches)
numTaps = 1
for j,touch in enumerate(associatedTouches[:-1]):
currentTouchTime = touch['time']
nextTouchTime = associatedTouches[j+1]['time']
if (nextTouchTime - currentTouchTime) > 100:
numTaps += 1
boxesWithTouches.append({'size': box['size'], 'position': box['position'], 'touches':associatedTouches, 'attempts':numTaps})
numTaps = 0
# Finish up with the last box
box = boxes[-1]
time = boxes[-1]['time']
nextTime = finishTime
def f(x): return x['time'] > time and x['time'] < nextTime
associatedTouches = filter(f, touches)
numTaps = 1
for j,touch in enumerate(associatedTouches[:-1]):
currentTouchTime = touch['time']
nextTouchTime = associatedTouches[j+1]['time']
if (nextTouchTime - currentTouchTime) > 100:
numTaps += 1
boxesWithTouches.append({'size': box['size'], 'position': box['position'], 'touches':associatedTouches, 'attempts':numTaps})
sizes = [30, 60, 99, 129]
mmsizes = [3,6,10,13]
for buttonSize in sizes:
def sizeOfBox(t): return t['size'] == buttonSize
filteredBoxes = filter(sizeOfBox, boxesWithTouches)
listOfAttempts = [box['attempts'] for box in filteredBoxes]
print "%d: %.3f/%.3f/%.3f/%.3f" % (mmsizes[sizes.index(buttonSize)], stats.mean(listOfAttempts), min(listOfAttempts), max(listOfAttempts), stats.stdev(listOfAttempts))
def letters_between_spaces(str):
#count the average word size
words = str.split()
wordCount = len(words)
ch = []
for word in words:
ch.append(len(word))
letterCountAverage = stats.mean(ch)
letterCountStdDev = stats.stdev(ch)
return None, {'letterAve/StdDev':letterCountAverage / letterCountStdDev}
def average(values):
"""Computes the arithmetic mean of a list of numbers.
>>> print average([20, 30, 70])
40.0
"""
try:
return stats.mean(values)
except ZeroDivisionError:
return None
def average(values):
"""Computes the arithmetic mean of a list of numbers.
>>> print average([20, 30, 70])
40.0
"""
try:
return stats.mean(values)
except ZeroDivisionError:
return None
def __init__(self, source_data, sample_size, test_name, threshold=0.01):
self.data = source_data
self.popmean = stats.mean(source_data)
self.sample_size = sample_size
self.rev_results = []
self.conf_results = []
self.simulation_result = {}
self.threshold = threshold
self.index = 0
self.test_name = test_name
self.template = {'sample_size' : self.sample_size, 'test_name' : self.test_name }
def getmeanstdev(dist, center):
# find the mean and standard deviation of the distance of each tract in a district from its centroid
buildlist = []
for bginfo in attributes:
if attributes[bginfo][13] == dist:
buildlist.append(sqrt((center[0] - attributes[bginfo][1][0])**2 + (center[1] - attributes[bginfo][1][1])**2))
return stats.mean(buildlist), stats.stdev(buildlist)
def getmeanstdev(dist, center):
# find the mean and standard deviation of the distance of each tract in a district from its centroid
buildlist = []
for bginfo in attributes:
if attributes[bginfo][13] == dist:
buildlist.append(
sqrt((center[0] - attributes[bginfo][1][0])**2 +
(center[1] - attributes[bginfo][1][1])**2))
return stats.mean(buildlist), stats.stdev(buildlist)
def amf(self, values, attr, func=None):
"""
Attribute mean filtered
For a list of objects, filter out an object with a attr value
of None, and return mean if any values are left.
"""
getter = self.op[attr]
res = (getter(x) for x in values if not getter(x) is None)
if func:
res = (func(x) for x in res if not func(x) is None)
res = tuple(res)
logger.debug("%s:%s", attr, res)
res = res and stats.mean(res) or 0.0
return res
def stats(self):
res = {}
for val in self.data.iteritems():
stat_report = {}
full_series = map(lambda x: x, val[1])
full_series = full_series[(
len(full_series) /
4):] # Cut off first quarter to get more reliable data
full_series_sorted = full_series
full_series_sorted.sort()
steady_series = full_series[int(len(full_series) * 0.7):]
stat_report['mean'] = stats.mean(full_series)
try:
stat_report['stdev'] = stats.stdev(full_series)
except ZeroDivisionError:
stat_report['stdev'] = 0
stat_report['upper_0.1_percentile'] = self.percentile(
full_series_sorted, 0.999)
stat_report['lower_0.1_percentile'] = self.percentile(
full_series_sorted, 0.001)
stat_report['upper_1_percentile'] = self.percentile(
full_series_sorted, 0.99)
stat_report['lower_1_percentile'] = self.percentile(
full_series_sorted, 0.01)
stat_report['upper_5_percentile'] = self.percentile(
full_series_sorted, 0.95)
stat_report['lower_5_percentile'] = self.percentile(
full_series_sorted, 0.05)
stat_report['steady_mean'] = stats.mean(steady_series)
try:
stat_report['steady_stdev'] = stats.stdev(full_series)
except ZeroDivisionError:
stat_report['steady_stdev'] = 0
res[val[0]] = stat_report
return res
def amf(self, values, attr, func=None):
"""
Attribute mean filtered
For a list of objects, filter out an object with a attr value
of None, and return mean if any values are left.
"""
getter = self.op[attr]
res = (getter(x) for x in values if not getter(x) is None)
if func:
res = (func(x) for x in res if not func(x) is None)
res = tuple(res)
logger.debug("%s:%s", attr, res)
res = res and stats.mean(res) or 0.0
return res
def main(args):
types=["tx payment","tx payment 02", "tx neworder", "tx delivery","tx orderstatus","tx orderstatus 02","tx stocklevel"]
outL=open("TPCC-latency-"+args[1]+".dat", 'w')
outT=open("TPCC-throughput-"+args[1]+".dat", 'w')
clients=[1]
if len(clients)!=(len(args)-2):
print "The size of clients it not compatible with the list of files."
sys.exit(0)
for i in range(2,len(args)):
fin=args[i]
throughput=0
mapLatency={}
print fin, clients[i-2]
for t in types:
mapLatency[t]=[]
mapLatency["total"]=[]
f = open(fin, 'r')
lines = f.readlines()
for line in lines:
sep=line[:-1].split(':')
if len(sep)>2 and sep[4]=="commit":
mapLatency[sep[6]].append(float(sep[3]))
mapLatency["total"].append(float(sep[3]))
elif sep[0]=="Measured tpmC":
throughput=float(sep[1])
print >>outT, clients[i-2], throughput
print >>outL, clients[i-2],
for t in types:
if len(mapLatency[t])>0:
print >>outL,stats.mean(mapLatency[t]),
else :
print >>outL,0,
print >>outL, stats.mean(mapLatency["total"])
f.close()
outL.close()
outT.close()
def _format_ratings(self, output):
ratings = []
for result in self.data:
try:
ratings.append( float(result[0].toPython()) )
except ValueError:
pass
output['results'] = {}
if ratings:
output['results']['median'] = stats.medianscore(ratings)
output['results']['mode'] = stats.mode(ratings)
output['results']['mean'] = stats.mean(ratings)
output['results']['histogram'] = stats.histogram(ratings,6)
output['results']['cumfreq'] = stats.cumfreq(ratings,6)
output['results']['count'] = len(ratings)
return output
def parseResultsFile(filename):
resultsFile = open(filename, 'r')
contents = resultsFile.read()
columns = contents.split("\n")[0].split(',')
data = {}
for value in columns:
data[value] = []
lines = contents.split("\n")
if len(lines) <= 1:
return None
for i in range(1,len(lines)):
items = lines[i].split(', ')
for i in range(len(items)):
data[columns[i]].append(items[i])
trials = str(len(data[data.keys()[0]]))
for key in data:
if key=='accuracy':
meanAccuracy = 0
for i in range(len(data[key])):
data[key][i] = float(data[key][i])
meanAccuracy += data[key][i]
meanAccuracy /= len(data[key])
meanAccuracy = '%.1f' % round(meanAccuracy, 1)
elif key=='overhead':
numeratorSum = 0
denominatorSum = 0
for i in range(len(data[key])):
value = data[key][i].split('/')
numeratorSum += int(value[0])
denominatorSum += int(value[1])
overhead = str( round(( numeratorSum * 100.0 / denominatorSum ) - 100,1) )
elif key=='timeElapsedTotal':
for i in range(len(data[key])):
data[key][i] = float( data[key][i] )
timeElapsed = str(round(stats.mean(data[key]),1))
return [meanAccuracy,overhead,timeElapsed,trials]
def final():
i = 0
iteracoes = zip(*totIteracoes)
print ' '
print ' '
print '******************************************************************'
print 'Media e desvio padrao das iteracoes:'
for prec in precs:
print '------------------------------------------------------------------'
print 'Precisao: %d' % prec
print 'Media: %d' % stats.mean(iteracoes[i])
print 'Maximo: %d' % max(iteracoes[i])
print 'Minimo: %d' % min(iteracoes[i])
print 'Desvio: %d' % stats.stdev(iteracoes[i])
i+=1
print '------------------------------------------------------------------'
ticks = range(1,i+1)
pylab.boxplot(iteracoes)
pylab.title('Distribuicao das Iteracoes')
pylab.xlabel('Precisao da raiz em casas decimais')
pylab.ylabel('Quantidade de Iteracoes')
pylab.xticks(ticks,precs)
pylab.show()
if delta_flag:
return delta
if __name__ == "__main__":
start_date = datetime.strptime(raw_input("Start date: "), '%Y%m%d')
day_range = int(raw_input("Day Range: "))
sample_days = int(raw_input("Sample days: "))
company_list = CompanyList(raw_input("Company List: "))
stocks_per_day = int(raw_input("Stocks per day: "))
percents_correct = [
float(p) for p in raw_input("Percents correct: ").split(",")
]
results = {}
for trial in range(len(percents_correct)):
deltas = run_experiment(company_list=company_list,
sample_days=sample_days,
start_date=start_date,
day_range=day_range,
percent_correct=percents_correct[trial],
stocks_per_day=stocks_per_day)
print "Percent correct: %f, %s" % (percents_correct[trial],
str(deltas))
print "\t (%f, %f)" % (stats.mean(deltas), stats.stdev(deltas))
results[percents_correct[trial]] = deltas
print results
# print "before winnings s1 = %s, s2 = %s, s3 = %s" % (stake1, stake2, stake3)
# Check the winnings
win1 = across.check_winnings(verbose=False)
if win1:
stake1 += win1
win2 = six_eight.check_winnings(verbose=False)
if win2:
stake2 += win2
win3 = come.check_winnings(verbose=False)
if win3:
stake3 += win3
# print "Roll<%s> s1 = %s, s2 = %s, s3 = %s" % (i, stake1, stake2, stake3)
# make sure all come bets have odds
for c_b in come.come_bets_wo_odds():
if come.play_come_bet_odds(c_b, line_odds):
stake3 -= line_odds
if debug:
print "Come: come bet odds of %s on %s" % (line_odds, c_b)
num_come_bets = come.num_come_bets()
print "Ending Profits p1: %d, p2: %d p3: %d" % ((stake1 - atm1), (stake2 - atm2), (stake3 - atm3))
profits1.append(stake1 - atm1)
profits2.append(stake2 - atm2)
profits3.append(stake3 - atm3)
# print "Stake (min, mean, max) = (%s, %s, %s)" % (min(stakes), stats.mean(stakes), max(stakes))
# print "ATM (min, mean, max) = (%s, %s, %s)" % (min(atms), stats.mean(atms), max(atms))
print "Profits across (min, mean, max) = (%s, %.2f, %.2f, %s)" % (min(profits1), stats.median(profits1), stats.mean(profits1), max(profits1))
print "Profits 6 and 8 (min, mean, max) = (%s, %.2f, %s)" % (min(profits2), stats.mean(profits2), max(profits2))
print "Profits3 2 come bet (min, mean, max) = (%s, %.2f, %s)" % (min(profits3), stats.mean(profits3), max(profits3))
reload(stats) import numpy N=numpy l = range(1,21) lf = range(1,21) lf[2] = 3.0 a = N.array(l) af = N.array(lf) ll = [l]*5 aa = N.array(ll) print '\nCENTRAL TENDENCY' print 'geometricmean:',stats.geometricmean(l), stats.geometricmean(lf), stats.geometricmean(a), stats.geometricmean(af) print 'harmonicmean:',stats.harmonicmean(l), stats.harmonicmean(lf), stats.harmonicmean(a), stats.harmonicmean(af) print 'mean:',stats.mean(l), stats.mean(lf), stats.mean(a), stats.mean(af) print 'median:',stats.median(l),stats.median(lf),stats.median(a),stats.median(af) print 'medianscore:',stats.medianscore(l),stats.medianscore(lf),stats.medianscore(a),stats.medianscore(af) print 'mode:',stats.mode(l),stats.mode(a) print '\nMOMENTS' print 'moment:',stats.moment(l),stats.moment(lf),stats.moment(a),stats.moment(af) print 'variation:',stats.variation(l),stats.variation(a),stats.variation(lf),stats.variation(af) print 'skew:',stats.skew(l),stats.skew(lf),stats.skew(a),stats.skew(af) print 'kurtosis:',stats.kurtosis(l),stats.kurtosis(lf),stats.kurtosis(a),stats.kurtosis(af) print 'tmean:',stats.tmean(a,(5,17)),stats.tmean(af,(5,17)) print 'tvar:',stats.tvar(a,(5,17)),stats.tvar(af,(5,17)) print 'tstdev:',stats.tstdev(a,(5,17)),stats.tstdev(af,(5,17)) print 'tsem:',stats.tsem(a,(5,17)),stats.tsem(af,(5,17)) print 'describe:' print stats.describe(l)
def test_mean(self):
"Testing mean"
data = [self.L, self.LF, self.A, self.AF]
for d in data:
self.EQ(stats.mean(d), 10.5, 3)
p.append(iprofile)
output = "Pathway analysis. Result dir: %s. Performed at %s" % (RESULT_DIR, str(datetime.now()))
output += "\n1. Statistics\n"
output += "----------------------------------------------------------------------------------------------------------------------------\n"
output += " Interaction_component_counts CoulombEnergy_Contribution \n"
output += " Box Sum_of_interacting_atoms CloseContact Hydrophobic HydrogenBond Electrostatic mean stddev \n"
output += "----------------------------------------------------------------------------------------------------------------------------\n"
pattern1= " %s %4s %s %s %s %s %10.3f %10.3f \n"
for i in range(len(p)):
elec_energies = p[i].statistics['coulomb_energies']
output += pattern1 % (i+1, p[i].statistics['sum'],
p[i].statistics['closecontact'],
p[i].statistics['hydrophobic'],
p[i].statistics['hydrogen'],
p[i].statistics['electrostatic'],
(stats.mean(elec_energies),0.0)[len(elec_energies) == 0],
(stats.stdev(elec_energies),0.0)[len(elec_energies) == 0]
)
OFILE = open('pathway_analysis.txt','w')
OFILE.write(output)
output = "\n2.Details. List of residues with high-frequency (>= 40%) of interactions in each box\n"
output += "---------------------------------------------------------------------------------------------\n"
output += " Box Residue Interaction_frequency Receptor_states\n"
output += " CloseContact Hydrophobic HydrogenBond Electrostatic All \n"
output += "---------------------------------------------------------------------------------------------\n"
pattern2= " %s %s %7.3f %7.3f %7.3f %7.3f %7.3f %s\n"
residue_set = []
for i in range(len(p)):
residue_set.append( [] )
for res in p[i].all_residues:
#!/usr/bin/python
import sys
import re
from statlib import stats
if __name__ == '__main__':
a = []
for i in xrange(501):
a.append([])
m = re.compile("(?P<l>\d+)\s(?P<m>\d+)")
L = sys.stdin.readlines()
for l in L:
s = m.match(l)
length = int(s.group("l"))
length -= length%10 +5
a[length].append(int(s.group("m")))
b = []
for i in xrange(200,501):
if (a[i] != []):
print i, stats.mean(a[i]), stats.stdev(a[i])
# b.append(len(a[i]))
# print stats.mean(b), stats.stdev(b)
def mean(self):
return stats.mean(self.deltas)
def avg_daily_profit(self, initial_value):
return stats.mean(self.daily_profit(initial_value))
#if qerrors.qsize():
#for err in qerrors:
#print(err)
#if qstart.qsize():
#print("START: {e}".format(e=qstart.qsize()))
print("Build times")
bstart = time.time()
times = []
#i =0
if qtimes.qsize():
qtimes.put(StopIteration)
#print(qtimes.qsize())
for item in qtimes:
#i += 1
#print(i, item)
times.append(item)
# The len of times[] indicates the number or successful responses.
# The len should equal max_connections * iterations from the command line.
print("Time spent building time[]: {t} len={l}".format(t=time.time() - bstart, l=len(times)))
print("Round trip time:")
print("Min {t}".format(t=min(times)))
print("Max {t}".format(t=max(times)))
if sys.version[0] == "2":
print("Mean {t}".format(t=stats.mean(times)))
print("StdDev {t}".format(t=stats.stdev(times)))
#print("Invalid responses={i}".format(i=invalid_responses))
def main(argv):
global sqlitefile
global csvfilename
csvfilename = None # need to set this to some sane default because ensureValidTestID() won't work without it
try:
sqlitefile = 'resultdb.sqlite'
opts, args = getopt.getopt(argv, 'hf:e:', ('help', 'db=', 'csv='))
except getopt.GetoptError:
usage()
for opt, arg in opts:
if opt in ('-h', '--help'):
usage()
elif opt in ('-f', '--db='):
sqlitefile = arg
ensureValidTestID()
elif opt in ('-e', '--csv='):
csvfilename = arg
ensureValidTestID()
writecsv(csvfilename, sometestid)
sys.exit(0)
# ---- INIT ----
# dbconn = sqlite3.connect(sqlitefile)
# dbconn.row_factory = sqlite3.Row
# c = dbconn.cursor()
getSQLiteConn()
myquery = 'SELECT test_id, date, hits, up, time, data, resptime, trans, bw, concur, ok, fail, long, short FROM siege WHERE test_id LIKE \'' + str(
sometestid) + '%\''
#todo = ['hits', 'up', 'time', 'data', 'resptime', 'trans', 'bw', 'concur', 'ok', 'fail', 'long', 'short']
floats = ('up', 'time', 'data', 'resptime', 'trans', 'bw', 'concur',
'long', 'short')
ints = ('hits', 'ok', 'fail')
# todo is a dict with each key as the col name and each val as a list containing all the vals
"""
Siege example return and var types
(u'mysql-1-1', u'1303101006.08', u'6830', u'85.88', u'352.12', u'48.83', u'5.05', u'19.40', u'0.14', u'97.88', u'6840', u'1123', u'15.41', u'0.56')
str(test_id)
int(date)
int(hits)
float(up)
float(time)
float(data)
float(resptime)
float(trans)
float(bw)
float(concur)
int(ok)
int(fail)
float(long)
float(short)
"""
mydict = {}
# create empty lists
for i in floats + ints:
mydict[i] = []
# we can now just map keys in our dict to results in the DB query since the names are 1:1
data = c.execute(myquery)
numrows = c.fetchone()
if numrows is None:
print "No tests found when using test ID selector:", sometestid
print "Displaying a list of test IDs in", sqlitefile
for row in c.execute('select test_id from siege'):
print row[0]
print '(For help / usage info, see', sys.argv[0], '--help)'
sys.exit(2)
for row in data:
for key in floats:
mydict[key].append(float(row[key]))
for key in ints:
mydict[key].append(int(row[key]))
meandict = {}
mediandict = {}
stdevdict = {}
for key, val in mydict.iteritems():
meandict[key] = stats.mean(val)
stdevdict[key] = stats.stdev(val)
mediandict[key] = getMedian(val)
print 'Test ID selector: ' + sometestid
print "Raw dump of dataset to parse: "
print mydict
print '\r\nMean: '
print meandict
print '\r\nMedian: '
print mediandict
print '\r\nStandard Deviation: '
print stdevdict
# select test_id, datetime(date, 'unixepoch') from siege where test_id = 'mysql-1-1';
#print mydict['trans']
# ---- MAIN ----
return
def mean_stdev(vals, null_val=-1):
vals2 = [i for i in vals if i != null_val]
return int(round(mean(vals2), 0)), stdev(vals2), len(vals2)
N = numpy
l = range(1, 21)
lf = range(1, 21)
lf[2] = 3.0
a = N.array(l)
af = N.array(lf)
ll = [l] * 5
aa = N.array(ll)
print '\nCENTRAL TENDENCY'
print 'geometricmean:', stats.geometricmean(l), stats.geometricmean(
lf), stats.geometricmean(a), stats.geometricmean(af)
print 'harmonicmean:', stats.harmonicmean(l), stats.harmonicmean(
lf), stats.harmonicmean(a), stats.harmonicmean(af)
print 'mean:', stats.mean(l), stats.mean(lf), stats.mean(a), stats.mean(af)
print 'median:', stats.median(l), stats.median(lf), stats.median(
a), stats.median(af)
print 'medianscore:', stats.medianscore(l), stats.medianscore(
lf), stats.medianscore(a), stats.medianscore(af)
print 'mode:', stats.mode(l), stats.mode(a)
print '\nMOMENTS'
print 'moment:', stats.moment(l), stats.moment(lf), stats.moment(
a), stats.moment(af)
print 'variation:', stats.variation(l), stats.variation(a), stats.variation(
lf), stats.variation(af)
print 'skew:', stats.skew(l), stats.skew(lf), stats.skew(a), stats.skew(af)
print 'kurtosis:', stats.kurtosis(l), stats.kurtosis(lf), stats.kurtosis(
a), stats.kurtosis(af)
print 'tmean:', stats.tmean(a, (5, 17)), stats.tmean(af, (5, 17))
p.append(iprofile)
output = "Pathway analysis. Result dir: %s. Performed at %s" % (
RESULT_DIR, str(datetime.now()))
output += "\n1. Statistics\n"
output += "----------------------------------------------------------------------------------------------------------------------------\n"
output += " Interaction_component_counts CoulombEnergy_Contribution \n"
output += " Box Sum_of_interacting_atoms CloseContact Hydrophobic HydrogenBond Electrostatic mean stddev \n"
output += "----------------------------------------------------------------------------------------------------------------------------\n"
pattern1 = " %s %4s %s %s %s %s %10.3f %10.3f \n"
for i in range(len(p)):
elec_energies = p[i].statistics['coulomb_energies']
output += pattern1 % (
i + 1, p[i].statistics['sum'], p[i].statistics['closecontact'],
p[i].statistics['hydrophobic'], p[i].statistics['hydrogen'],
p[i].statistics['electrostatic'],
(stats.mean(elec_energies), 0.0)[len(elec_energies) == 0],
(stats.stdev(elec_energies), 0.0)[len(elec_energies) == 0])
OFILE = open('pathway_analysis.txt', 'w')
OFILE.write(output)
output = "\n2.Details. List of residues with high-frequency (>= 40%) of interactions in each box\n"
output += "---------------------------------------------------------------------------------------------\n"
output += " Box Residue Interaction_frequency Receptor_states\n"
output += " CloseContact Hydrophobic HydrogenBond Electrostatic All \n"
output += "---------------------------------------------------------------------------------------------\n"
pattern2 = " %s %s %7.3f %7.3f %7.3f %7.3f %7.3f %s\n"
residue_set = []
for i in range(len(p)):
residue_set.append([])
for res in p[i].all_residues:
if p[i].frequency(res) >= 0.4:
def histogram(self, out_fname, large=False):
assert self.data
# Hacky workaround in the case that a run had no data.
for x in self.data.values():
if len(x) == 0: x.extend([0, 0])
if not large:
font = fm.FontProperties(family=['sans-serif'],
size='small',
fname=FONT_FILE)
mpl.rcParams['xtick.major.pad'] = 4
mpl.rcParams['ytick.major.pad'] = 4
mpl.rcParams['lines.linewidth'] = 1
else:
font = fm.FontProperties(family=['sans-serif'],
size=36,
fname=FONT_FILE)
mpl.rcParams['xtick.major.pad'] = 20
mpl.rcParams['ytick.major.pad'] = 20
mpl.rcParams['lines.linewidth'] = 5
fig = plt.figure()
# Set the margins for the plot to ensure a minimum of whitespace
ax = plt.axes([0.12, 0.12, 0.85, 0.85])
data = map(lambda x: x[1], self.data.iteritems())
mean = stats.mean(map(lambda x: x, reduce(lambda x, y: x + y, data)))
stdev = stats.stdev(map(lambda x: x, reduce(lambda x, y: x + y, data)))
labels = []
hists = []
for series, color in zip(self.data.iteritems(), colors):
clipped_data = clip(series[1], 0, 3 * mean)
if clipped_data:
_, _, foo = ax.hist(clipped_data,
bins=200,
histtype='bar',
facecolor=color,
alpha=.5,
label=series[0])
hists.append(foo)
labels.append(series[0])
else:
print "Tried to make a histogram of a series of size 0"
for tick in ax.xaxis.get_major_ticks():
tick.label1.set_fontproperties(font)
for tick in ax.yaxis.get_major_ticks():
tick.label1.set_fontproperties(font)
ax.set_ylabel('Frequency', fontproperties=font)
ax.set_xlabel(
'Latency (microseconds)', fontproperties=font
) #simply should not be hardcoded but we want nice pictures now
ax.grid(True)
# Dirty hack to get around legend miscoloring: drop all the hists generated into the legend one by one
if hists:
plt.legend(map(lambda x: x[0], hists), labels, loc=1, prop=font)
if not large:
fig.set_size_inches(5, 3.7)
fig.set_dpi(90)
plt.savefig(out_fname, bbox_inches="tight")
else:
ax.yaxis.LABELPAD = 40
ax.xaxis.LABELPAD = 40
fig.set_size_inches(20, 14.8)
fig.set_dpi(300)
plt.savefig(out_fname, bbox_inches="tight")
def cull_outliers(data, n_sigma):
mean = stats.mean(map(lambda x: x, data))
sigma = stats.stdev(map(lambda x: x, data))
return filter(lambda x: abs(x - mean) < n_sigma * sigma, data)
N = numpy
l = list(range(1, 21))
lf = list(range(1, 21))
lf[2] = 3.0
a = N.array(l)
af = N.array(lf)
ll = [l] * 5
aa = N.array(ll)
print('\nCENTRAL TENDENCY')
print('geometricmean:', stats.geometricmean(l), stats.geometricmean(lf),
stats.geometricmean(a), stats.geometricmean(af))
print('harmonicmean:', stats.harmonicmean(l), stats.harmonicmean(lf),
stats.harmonicmean(a), stats.harmonicmean(af))
print('mean:', stats.mean(l), stats.mean(lf), stats.mean(a), stats.mean(af))
print('median:', stats.median(l), stats.median(lf), stats.median(a),
stats.median(af))
print('medianscore:', stats.medianscore(l), stats.medianscore(lf),
stats.medianscore(a), stats.medianscore(af))
print('mode:', stats.mode(l), stats.mode(a))
print('\nMOMENTS')
print('moment:', stats.moment(l), stats.moment(lf), stats.moment(a),
stats.moment(af))
print('variation:', stats.variation(l), stats.variation(a),
stats.variation(lf), stats.variation(af))
print('skew:', stats.skew(l), stats.skew(lf), stats.skew(a), stats.skew(af))
print('kurtosis:', stats.kurtosis(l), stats.kurtosis(lf), stats.kurtosis(a),
stats.kurtosis(af))
print('tmean:', stats.tmean(a, (5, 17)), stats.tmean(af, (5, 17)))
total_DFP = []
mean_DFP = []
# mean2_DFP = []
for dfp in xrange(len(DFP_e.times)):
total_DFP.append(sum(DFP_e[:,dfp]))
mean_DFP.append(float(sum(DFP_e[:,dfp]))/N_Excitatory)
# mean2_DFP.append(st.mean(DFP_e[:,dfp]))
# Mean membrane
mean_membrane = []
for i_v in xrange(len(Membrane.times)):
mean_membrane.append(st.mean(Membrane[:,i_v]))
# Convert volt to mili-volt
mean_membrane[:] = [x*1e3 for x in mean_membrane]
#total_LFP[:] = [x*1e3 for x in total_LFP]
mean_LFP[:] = [x*1e3 for x in mean_LFP]
#total_DFP[:] = [x*1e3 for x in total_DFP]
mean_DFP[:] = [x*1e3 for x in mean_DFP]
#------------------- Various Plots ---------------------
pylab.figure(1)
#pylab.yticks((0,0.5, 1))
plot(ThalamicRate.times/ms, ThalamicRate[0]/1000, 'k')
pylab.plot(ThalamicRate.times/ms, signal/1000, 'g')
def __parsePassage(self):
tokenize_sent = PunktSentenceTokenizer() #Sentence tokenizer
tokenize_word = PunktWordTokenizer() #Word Tokenizer
sentences = tokenize_sent.tokenize(
self.corpus) #tokenize passage into sentences
pos_corpus = []
neg_corpus = []
self.pos_n = 0
self.neg_n = 0
for sentence in sentences:
#print sentence
sentence_scores = []
pos_tally = []
neg_tally = []
sent_pos_n = 0
sent_neg_n = 0
flip = False
for word_tag in self.brill_tagger.tag(
tokenize_word.tokenize(sentence)
): #for word_tag in tokenize_word.tokenize(sentence):
pos_score, neg_score = self.__scorePassage(
word_tag[0], word_tag[1])
if flip: #switch negative and positive scores
sentence_scores.append([neg_score, pos_score])
else:
sentence_scores.append([pos_score, neg_score])
if word_tag[0] in self.negations: #from now on flip scores
if flip:
flip = False
else:
flip = True
for score in sentence_scores:
if score[0] != None:
pos_tally.append(score[0])
pos_corpus.append(score[0])
if score[1] != None:
neg_tally.append(score[1])
neg_corpus.append(score[1])
if score[0] > score[1]:
sent_pos_n = sent_pos_n + 1
self.pos_n = self.pos_n + 1
elif score[0] < score[1]:
sent_neg_n = sent_neg_n + 1
self.neg_n = self.neg_n + 1
try:
#TTest_Ind calculates our scores and probability of make an error in 5% of cases
sen_t_score, sen_t_prob = stats.ttest_ind(pos_tally, neg_tally)
except: #A zero division error
sen_t_score, sen_t_prob = 0, 0
try:
sent_pos_mean = stats.mean(pos_tally)
except:
sent_pos_mean = 0
try:
sent_neg_mean = stats.mean(neg_tally)
except:
sent_neg_mean = 0
self.scoredPassage.append({
'sentence': sentence,
'pos_mean': sent_pos_mean,
'neg_mean': sent_neg_mean,
'pos_n': sent_pos_n,
'neg_n': sent_neg_n,
't_score': sen_t_score,
't_prob': sen_t_prob
}) #append the sentence and its scores
#Calculate the T-Score
self.pos_mean = stats.mean(pos_corpus)
self.neg_mean = stats.mean(neg_corpus)
try:
self.t_score, self.t_prob = stats.ttest_ind(pos_corpus, neg_corpus)
except: #A zero division error
self.t_score, self.t_prob = 0, 0
print "Finished Parsing and scoring"
def __parsePassage(self):
tokenize_sent = PunktSentenceTokenizer() #Sentence tokenizer
tokenize_word = PunktWordTokenizer() #Word Tokenizer
sentences = tokenize_sent.tokenize(self.corpus) #tokenize passage into sentences
pos_corpus = []
neg_corpus = []
self.pos_n = 0
self.neg_n = 0
for sentence in sentences:
#print sentence
sentence_scores = []
pos_tally = []
neg_tally = []
sent_pos_n = 0
sent_neg_n = 0
flip = False
for word_tag in self.brill_tagger.tag(tokenize_word.tokenize(sentence)): #for word_tag in tokenize_word.tokenize(sentence):
pos_score, neg_score = self.__scorePassage(word_tag[0], word_tag[1])
if flip: #switch negative and positive scores
sentence_scores.append([neg_score, pos_score])
else:
sentence_scores.append([pos_score, neg_score])
if word_tag[0] in self.negations: #from now on flip scores
if flip:
flip = False
else:
flip = True
for score in sentence_scores:
if score[0] != None:
pos_tally.append(score[0])
pos_corpus.append(score[0])
if score[1] != None:
neg_tally.append(score[1])
neg_corpus.append(score[1])
if score[0] > score[1]:
sent_pos_n = sent_pos_n + 1
self.pos_n = self.pos_n + 1
elif score[0] < score[1]:
sent_neg_n = sent_neg_n + 1
self.neg_n = self.neg_n + 1
try:
#TTest_Ind calculates our scores and probability of make an error in 5% of cases
sen_t_score, sen_t_prob = stats.ttest_ind(pos_tally, neg_tally)
except: #A zero division error
sen_t_score, sen_t_prob = 0, 0
try:
sent_pos_mean = stats.mean(pos_tally)
except:
sent_pos_mean = 0
try:
sent_neg_mean = stats.mean(neg_tally)
except:
sent_neg_mean = 0
self.scoredPassage.append({'sentence':sentence,
'pos_mean':sent_pos_mean,
'neg_mean':sent_neg_mean,
'pos_n':sent_pos_n,
'neg_n':sent_neg_n,
't_score':sen_t_score ,
't_prob':sen_t_prob}) #append the sentence and its scores
#Calculate the T-Score
self.pos_mean = stats.mean(pos_corpus)
self.neg_mean = stats.mean(neg_corpus)
try:
self.t_score, self.t_prob = stats.ttest_ind(pos_corpus, neg_corpus)
except: #A zero division error
self.t_score, self.t_prob = 0, 0
print "Finished Parsing and scoring"
def main():
if (len(sys.argv) < 3):
print "Usage!"
exit(1)
points = sys.argv[1]
database = sys.argv[2]
boxData = csv.reader(open(points, 'rb'))
boxes = []
for row in boxData:
if (len(row) == 4):
boxes.append({"time":long(row[0]), "size":float(row[1]), "position":(int(row[2]),int(row[3]))})
else:
finishTime = long(row[0].split(':')[1])
conn = sqlite3.connect(database)
cur = conn.cursor()
cur.execute('select datetime,data from clues where kind="touch" and datetime between %d and %d' % (boxes[0]['time'],finishTime))
touches = []
for touch in cur:
time = long(touch[0])
data = touch[1].split(',')
touches.append({"time":long(touch[0]), "position":(int(data[0]),int(data[1])), "pressure":float(data[2])})
timesForSize = {30:[], 60:[], 99:[], 129:[]}
deltas = []
for i,box in enumerate(boxes[:-1]):
delta = (boxes[i+1]['time'] - box['time'])/1000.0
timesForSize[box['size']].append(delta)
deltas.append(delta)
deltas.append((finishTime - boxes[-1]['time'])/1000.0)
minimum = min(deltas)
maximum = max(deltas)
mean = stats.mean(deltas)
stddev = stats.stdev(deltas)
for k,v in sorted(timesForSize.iteritems()):
print "%d: %.3f/%.3f/%.3f/%.3f (%.3f bps)" % (k, min(v), stats.mean(v), max(v), stats.stdev(v), 1/stats.mean(v))
print "Avg: %.3f/%.3f/%.3f/%.3f (%.3f boxes per second)" % (minimum, mean, maximum, stddev, 1/mean)
boxesWithTouches = []
for i,box in enumerate(boxes[:-1]):
time = box['time']
nextTime = boxes[i+1]['time']
def f(x): return x['time'] > time and x['time'] < nextTime
associatedTouches = filter(f, touches)
boxesWithTouches.append({'size': box['size'], 'position': box['position'], 'touches':associatedTouches})
mags = []
magsPerSize = []
sizes = [30, 60, 99, 129]
for buttonSize in sizes:
def sizeOfBox(t): return t['size'] == buttonSize
boxes = filter(sizeOfBox, boxesWithTouches)
for boxWithTouch in boxes:
center = boxWithTouch['position']
for touch in boxWithTouch['touches']:
tapPos = touch['position']
deltaX = center[0] - tapPos[0]
deltaY = center[1] - tapPos[1]
mags.append(math.sqrt(pow(deltaX, 2) + pow(deltaY, 2)))
magsPerSize = magsPerSize + mags
mags = []
magsPerSize = []
b.place_the_number(i, 6)
stake -= 6
if debug:
print "placing across, stake = %s" % stake
g.roll_dice(verbose=debug)
if debug:
print b.show_bets()
win = b.check_winnings(verbose=debug)
if win:
stake += win
if debug:
print "Roll %s stake = %s" % (i, stake)
print "Ending Stake = %s, ATM withdraws = %s" % (stake, atm)
stakes.append(stake)
atms.append(atm)
profits.append(stake - atm)
# print "Stake (min, mean, max) = (%s, %s, %s)" % (min(stakes), stats.mean(stakes), max(stakes))
# print "ATM (min, mean, max) = (%s, %s, %s)" % (min(atms), stats.mean(atms), max(atms))
print "Profits (min, mean, max) = (%s, %s, %s)" % (min(profits), stats.mean(profits), max(profits))
hist = stats.histogram(profits)
stake_bins = hist[0]
stake_start = hist[1]
stake_width = hist[2]
print "Profits histogram:"
for b in stake_bins:
print "%s - %s: %s" % (stake_start, stake_start + stake_width, b)
stake_start += stake_width
label.set_rotation(45)
plt.savefig('performance-bargraph.png', width = 800, height = 600, dpi = 100, bbox_inches = 'tight')
# with open('logs/socks-over-ssh.log') as f:
with open('logs/socks-over-fte.log') as f:
contents = f.read().strip()
formats = {}
for line in contents.split('\n'):
key = line.split(',')[-1]
if line.split(',')[3] == 'ERROR': continue
if not formats.get(key):
formats[key] = []
val = float(line.split(',')[3])
formats[key].append(val)
keys = formats.keys()
keys.sort()
for key in keys:
formats[key].sort()
data = {}
for key in keys:
if key.endswith('ssh') or key.endswith('http'):
data[key] = stats.mean(formats[key])
data['socks-overs-ssh'] = 6.2
mkGraph(data)
# run in wt/visual-cluster
from statlib import stats
OFILE = open("stats.txt",'w')
for i in range(1,8):
BEs = []
IFILE = open("visual_cluster-%s.pdb" % i, 'r')
for l in IFILE:
values = l.split()
BEs.append(float(values[9]) / 0.7) # if given BEs are weighted
OFILE.write("visual_cluster-%s: %s, stddev %s, lower %s, upper %s, min %s, max %s, median %s \n" % (i,stats.mean(BEs),
stats.stdev(BEs),
stats.scoreatpercentile(BEs,25),
stats.scoreatpercentile(BEs,75),
min(BEs), max(BEs),
stats.median(BEs) ))
OFILE.close()
