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 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 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 __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 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()