def printLEMranks(results_file,LEM_file,fname="LEMranks.txt",use_pldLap=False,plotresults=False,title="11D malaria 40 hr 90 TF, scaling factor 0.05"): # use_pldLap = False or 0 means use sqrt loss / root if use_pldLap: source,target,type_reg,lem_score = fileparsers.parseLEMfile(-1,LEM_file) else: source,target,type_reg,sqrtlossdroot_score = fileparsers.parseLEMfile_sqrtlossdroot(2,LEM_file) totaledges = float(len(source)) results = json.load(open(results_file,'r')) try: network_spec_str = results["Network"] LEMranks = getLEMranks(network_spec_str,totaledges,source,target,type_reg) print "Mean: {}".format(statistics.mean(LEMranks)) print "Median: {}".format(statistics.median(LEMranks)) print "% stable FCs: {}".format(float(results["StableFCParameterCount"])/float(results["ParameterCount"])) print "% pattern matches: {}".format(float(results["StableFCMatchesParameterCount"])/float(results["ParameterCount"])) except: stats=[] for R in results: network_spec_str = R["Network"] LEMranks = getLEMranks(network_spec_str,totaledges,source,target,type_reg) stats.append( (statistics.mean(LEMranks),statistics.median(LEMranks),float(R["StableFCMatchesParameterCount"])/float(R["ParameterCount"])) ) with open(fname,'w') as sf: for s in stats: sf.write('/'.join([str(t) for t in s])+"\n") if plotresults: plotLEMranks(stats,title,use_pldLap)
def indexStats_by_year(year): area_repo = AreaRepository(recreate_db=False, config=sqlite_config) indicator_repo = IndicatorRepository(recreate_db=False, config=sqlite_config) observation_repo = ObservationRepository(recreate_db=False, area_repo=area_repo, indicator_repo=indicator_repo, config=sqlite_config) index_indicator = indicator_repo.find_indicators_index()[0] observations = observation_repo.find_tree_observations(index_indicator.indicator, 'ALL', year, 'INDICATOR') areas = area_repo.find_countries(order="iso3") data = {'year': year, 'stats': OrderedDict()} for region in area_repo.find_regions(): per_region_obs = [o for o in observations if o.value is not None and o.area.iso3 in [c.iso3 for c in region.countries]] for indicator_code in sorted(set([o.indicator.indicator for o in observations])): per_indicator_obs = [o.value for o in per_region_obs if o.indicator.indicator == indicator_code and o.value is not None] if region.iso3 not in data['stats']: data['stats'][region.iso3] = OrderedDict() data['stats'][region.iso3][indicator_code] = OrderedDict() data['stats'][region.iso3][indicator_code]['mean'] = statistics.mean(per_indicator_obs) data['stats'][region.iso3][indicator_code]['median'] = statistics.median(per_indicator_obs) data['stats'][':::'] = OrderedDict() for indicator_code in sorted(set([o.indicator.indicator for o in observations])): per_indicator_obs = [o.value for o in observations if o.indicator.indicator == indicator_code and o.value is not None] data['stats'][':::'][indicator_code] = OrderedDict() data['stats'][':::'][indicator_code]['mean'] = statistics.mean(per_indicator_obs) data['stats'][':::'][indicator_code]['median'] = statistics.median(per_indicator_obs) return json_response_ok(request, data)
def getSpeedAfterShock(self, time = 20, startTime = 0, after = 25, absolute = False): "returns direction that the rat travelled 'after' points after shock" time = time * 60000 start = self.findStart(startTime) shocks = [content[0] for content in self.data[start:] if content[5] == 2 and content[1] < time] if shocks: selected = [shocks[0]] prev = shocks[0] for shock in shocks[1:]: if shock - prev > after: selected.append(shock) prev = shock else: return "NA" angles = [] cx, cy = self.centerX, self.centerY for shock in selected: x1, y1 = self.data[shock][7:9] if len(self.data) <= shock + after: break x2, y2 = self.data[shock + after][7:9] angle = ((degrees(atan2(x2 - cx, y2 - cy + 0.0000001)) - degrees(atan2(x1 - cx, y1 - cy + 0.0000001)) + 180) % 360) - 180 angles.append(angle) if absolute: return format(median([abs(angle) for angle in angles]), "0.2f") else: return format(median(angles), "0.2f")
def parse_life_1_06(pattern): lines = repr(pattern).split(r'\r\n') x_vals = [] y_vals = [] board = new_array() for line in lines[1::]: if len(line) > 1: x_vals.append(int(line.split()[0])) y_vals.append(int(line.split()[1])) w_padding = (width - len(set(x_vals))) // 2 h_padding = (height - len(set(y_vals))) // 2 if floor(median(x_vals)) < w_padding: diff = (floor(median(x_vals)) * -1) + w_padding for x in range(len(x_vals.copy())): x_vals[x] += diff if floor(median(y_vals)) < h_padding: diff = floor((median(y_vals)) * -1) + h_padding for y in range(len(y_vals.copy())): y_vals[y] += diff for i in range(len(x_vals)): board[y_vals[i]][x_vals[i]] = 1 game(0, load_board=board, rescan=True)
def numerical_col_processing(numeric_column_names, dataset_df): for col_name in numeric_column_names: value_list = list(dataset_df[col_name]) value_list.sort() max_value = dataset_df[col_name].max() min_value = dataset_df[col_name].min() first_median = statistics.median(value_list) break_index = 0 temp_list1 = [] for i in value_list: if i < first_median: temp_list1.append(i) elif i == first_median: temp_list1.append(i) break_index = value_list.index(i) else: break second_median = statistics.median(temp_list1) temp_list2 = [] for j in range(break_index, len(value_list)): temp_list2.append(value_list[j]) third_median = statistics.median(temp_list2) bins = [min_value-1, second_median, first_median, third_median, max_value+1] group_names = [str(min_value)+"-"+str(second_median), str(second_median)+"-"+str(first_median), str(first_median)+"-"+str(third_median), str(third_median)+"-"+str(max_value)] dataset_df[col_name] = pd.cut(dataset_df[col_name], bins, labels=group_names) return dataset_df
def get_pivot(a: list): l = len(a) if l >= 9: return statistics.median([a[i * (l // 9)] for i in range(9)]) if l >= 3: return statistics.median([a[i * (l // 3)] for i in range(3)]) return a[0]
def parse_plaintext(pattern): lines = repr(pattern).split(r'\r\n') x_vals = [] y_vals = [] board = new_array() cell_block_start = [i for i in range(len(lines)) if lines[i][0:1] != '!' and lines[i][0:2] != "'!"][0] for y in range(cell_block_start, len(lines)): for x in range(len(lines[y])): if lines[y][x] == "O": x_vals.append(x) y_vals.append(y) w_padding = (width - len(set(x_vals))) // 2 h_padding = (height - len(set(y_vals))) // 2 if floor(median(x_vals)) < w_padding: diff = (floor(median(x_vals)) * -1) + w_padding for x in range(len(x_vals.copy())): x_vals[x] += diff if floor(median(y_vals)) < h_padding: diff = floor((median(y_vals)) * -1) + h_padding for y in range(len(y_vals.copy())): y_vals[y] += diff for i in range(len(x_vals)): board[y_vals[i]][x_vals[i]] = 1 game(0, load_board=board, rescan=True)
def googlemap_position(request, trackerID): pk = trackerID.split(":")[0] current_user = request.user horsetracker = get_object_or_404(HorseTracker, pk=pk) horsedata = HorseData.objects.filter(tracker=horsetracker).order_by('-date') if( horsetracker.user != current_user ): raise Http404 #convert strings to float, int latitude = horsedata.values('latitude') longitude = horsedata.values('longitude') temperature = horsedata.values('temperature') latitude_list = [x['latitude'] for x in latitude] longitude_list = [x['longitude'] for x in longitude] temperature_list = [x['temperature'] for x in temperature] latCenter = statistics.median(latitude_list)#6216576 lonCenter = statistics.median(longitude_list)#1717866 #step = 3 points=[ dict(latitude=str(latCenter), longitude=str(lonCenter), value2=str(0) )] counter = 0 for i in range(len(latitude_list)): points.append( dict(latitude=str(latitude_list[i]), longitude=str(longitude_list[i]))) return render(request, 'googlemap_position.html', { 'horsetracker': horsetracker, 'horsedatas': horsedata, 'points': points })
def find_medians(self): """ Find true_median, high_median, low_median. """ # find median self.true_median = statistics.median(self.data_list) # find low_median, high_median # If input list is even if len(self.data_list) % 2 == 0: low_half = [self.data_list[val] for val in range(len(self.data_list) // 2 - 1)] top_half = [self.data_list[val2] for val2 in range(len(self.data_list) // 2 + 1, len(self.data_list))] print(low_half, top_half) self.low_median = statistics.median(low_half) self.high_median = statistics.median(top_half) # If input list is odd elif len(self.data_list) % 2 != 0: low_half = [self.data_list[val] for val in range(len(self.data_list) // 2)] top_half = [self.data_list[val] for val in range(len(self.data_list) // 2 + 1, len(self.data_list))] print(low_half, top_half, sep='\n') self.low_median = statistics.median(low_half) self.high_median = statistics.median(top_half) return self.true_median, self.low_median, self.high_median
def write_result_avg_rand_planner(problem, params, simulations, file_obj_avg): # About this simulation to_write = problem.name to_write += "\t{}\t{}\t{}".format(params.planner.name, params.model.__name__, params.coc) # Results avg_cost = 1.0 * sum([s.get_total_cost() for s in simulations]) /len(simulations) to_write += '\t' + str(avg_cost) avg_obs = 1.0 * sum([s.total_observations() for s in simulations])/len(simulations) to_write += '\t' + str(avg_obs) avg_msg_sent = 1.0 * sum([s.total_messages_sent() for s in simulations])/len(simulations) to_write += '\t' + str(avg_msg_sent) avg_msg_void = 1.0 * sum([s.total_messages_voided() for s in simulations])/len(simulations) to_write += '\t' + str(avg_msg_void) avg_steps = 1.0 * sum([s.total_steps() for s in simulations])/len(simulations) to_write += '\t' + str(avg_steps) # Median Results avg_cost = 1.0 * statistics.median([s.get_total_cost() for s in simulations]) to_write += '\t' + str(avg_cost) avg_obs = 1.0 * statistics.median([s.total_observations() for s in simulations]) to_write += '\t' + str(avg_obs) avg_msg_sent = 1.0 * statistics.median([s.total_messages_sent() for s in simulations]) to_write += '\t' + str(avg_msg_sent) avg_msg_void = 1.0 * statistics.median([s.total_messages_voided() for s in simulations]) to_write += '\t' + str(avg_msg_void) avg_steps = 1.0 * statistics.median([s.total_steps() for s in simulations]) to_write += '\t' + str(avg_steps) to_write += '\t' + str(len(simulations)) file_obj_avg.write(to_write + '\n') file_obj_avg.flush()
def addDataToPlt(fig, ax, dates, diff, c = 'c', label="raw", isMultiple=True): assert len(dates) == len(diff), "Plot and data are of different lenght" label1 = "average of 3" label2 = "average of 7" med3 = [i for i in diff] med7 = [i for i in diff] for i in range(3, len(diff) - 4): if i > 2 and i < len(diff) - 4: med7[i] = stats.median(diff[i-3:i+3]) if i > 0 and i < len(diff) - 2: med3[i] = stats.median(diff[i-1:i+2]) marker = "o" if len(diff) > 200: marker = "." if not isMultiple: if len(diff) > 1 and stats.stdev(diff) > 0.1: logger.error("Why do you have a high stdev?" + str(stats.stdev(diff))) marker = "x" ax.plot_date(dates, diff, c, xdate=True, marker = marker, linestyle="", label=label) if isMultiple: ax.plot_date(dates, med3, 'b', xdate=True, marker = ".", linestyle="", label=label1) ax.plot_date(dates, med7, 'r', xdate=True, marker = ".", linestyle="", label=label2) ax.xaxis.set_major_locator(matplotlib.dates.HourLocator()) ax.xaxis.set_major_formatter(matplotlib.dates.DateFormatter("%H:00")) ax.xaxis.set_minor_locator(matplotlib.dates.MinuteLocator()) ax.autoscale_view() fig.autofmt_xdate() ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
def stats(responses, last=100): def t(s): return ("\t" + s).ljust(20) def f(s): return "{:.2f}ms".format(s * 1000) values = responses if len(values) < 3: print("\tNot enough data") return if len(values) > last: print(t("COUNT"), len(values), "(but only using the last {})".format(last)) values = values[-last:] else: print(t("COUNT"), len(values)) if any([x["cache"] for x in values]): hits = len([x for x in values if x["cache"] == "HIT"]) misses = len([x for x in values if x["cache"] == "MISS"]) print(t("HIT RATIO"), "{:.1f}%".format(100 * hits / (hits + misses))) print(t("AVERAGE (all)"), f(statistics.mean([x["took"] for x in values]))) print(t("MEDIAN (all)"), f(statistics.median([x["took"] for x in values]))) try: print( t("AVERAGE (misses)"), f(statistics.mean([x["took"] for x in values if x["cache"] == "MISS"])), ) print( t("MEDIAN (misses)"), f( statistics.median( [x["took"] for x in values if x["cache"] == "MISS"] ) ), ) print( t("AVERAGE (hits)"), f(statistics.mean([x["took"] for x in values if x["cache"] == "HIT"])), ) print( t("MEDIAN (hits)"), f( statistics.median( [x["took"] for x in values if x["cache"] == "HIT"] ) ), ) except statistics.StatisticsError as exc: print(exc) else: hits = len([x for x in values if x["link"]]) misses = len([x for x in values if not x["link"]]) print(t("HIT RATIO"), "{:.1f}%".format(100 * hits / (hits + misses))) print(t("AVERAGE"), f(statistics.mean([x["took"] for x in values]))) print(t("MEDIAN"), f(statistics.median([x["took"] for x in values]))) with open("cdn-crawler-stats.json", "w") as f: json.dump(responses, f, indent=3)
def resetPass(customCommand,test=False): from random import sample as randomize from random import random from os.path import exists # Opens the Adj, Adv, and Noun files as arrays av = open(sys.path[0]+"/Adv").read().splitlines() aj = open(sys.path[0]+"/Adj").read().splitlines() nn = open(sys.path[0]+"/Noun").read().splitlines() # Just for fun, some statistics! totalCombos = len(av)*len(aj)*len(nn) combosFormatted = "{:,}".format(totalCombos) avLengths=[] for item in av: avLengths.append(len(item)) ajLengths=[] for item in aj: ajLengths.append(len(item)) nnLengths=[] for item in nn: nnLengths.append(len(item)) from statistics import mean,median,mode print("-"*25+"\n"+ "Total adverbs: "+str(len(av))+"\n"+ "Total adjectives: "+str(len(aj))+"\n"+ "Total nouns: "+str(len(nn))+"\n"+ "Total possible combinations: "+combosFormatted+" (not factoring in numbers)\n"+ "Shortest possible passphrase length: "+str(min(avLengths)+min(ajLengths)+min(nnLengths))+"\n"+ "Longest possible passphrase length: "+str(max(avLengths)+max(ajLengths)+max(nnLengths)+5)+"\n"+ "Mean passphrase length: "+str(int(mean(avLengths)+mean(ajLengths)+mean(nnLengths)+4))+"\n"+ "Median passphrase length: "+str(int(median(avLengths)+median(ajLengths)+median(nnLengths))+4)+"\n"+ "Mode passphrase length: "+str(int(mode(avLengths)+mode(ajLengths)+mode(nnLengths))+4)+"\n"+ "-"*25) # Randomize the order of the arrays av = randomize(av,len(av)) aj = randomize(aj,len(aj)) nn = randomize(nn,len(nn)) # Pick a random word from each randomized array newAdverb = av[int(random()*len(av))].capitalize() newAdjective = aj[int(random()*len(aj))].capitalize() newNoun = nn[int(random()*len(nn))].capitalize() # Possibly add a random number from 1 to 10,000 if maybeNumber(): from math import ceil number = str(ceil(random()*10000)) else: number = '' # Assemble the passphrase newPassphrase = number+newAdverb+newAdjective+newNoun #################################################################### Needs attention print("The new passphrase will be: "+newPassphrase) print("Total entropy: ~"+str(int(entropy(newPassphrase)))) if customCommand == ' {PASSPHRASE}': print("Password display command not found. Aborting.") exit() if not test: import RouterPasswording RouterPasswording.newPassphrase(newPassphrase) from os import system as execute execute(customCommand.replace("{password}",newPassphrase).replace("{passphrase}",newPassphrase))
def run(parser, args): if args.full_tsv: files = 0 basecalled_files = 0 stats = defaultdict(list) for fast5 in Fast5File.Fast5FileSet(args.files): files += 1 fas = fast5.get_fastas_dict() if len(fas) > 0: basecalled_files += 1 for category, fa in fas.iteritems(): if fa is not None: stats[category].append(len(fa.seq)) if category == 'twodirections': if fast5.is_high_quality(): stats['2D_hq'].append(len(fa.seq)) fast5.close() print "files\ttotal reads\t%d" % (files) print "files\ttotal base-called reads\t%d" % (basecalled_files) for category in sorted(stats.keys()): sizes = stats[category] if len(sizes) > 0: print "%s\ttotal reads\t%d" % (category, len(sizes)) print "%s\ttotal base pairs\t%d" % (category, sum(sizes)) print "%s\tmean\t%.2f" % (category, stat.mean(sizes)) print "%s\tmedian\t%d" % (category, stat.median(sizes)) print "%s\tmin\t%d" % (category, min(sizes)) print "%s\tmax\t%d" % (category, max(sizes)) nxvalues = stat.NX(sizes, [25,50,75]) print "%s\tN25\t%d" % (category, nxvalues[25]) print "%s\tN50\t%d" % (category, nxvalues[50]) print "%s\tN75\t%d" % (category, nxvalues[75]) else: logger.warning("No valid sequences observed.\n") else: sizes = [] for fast5 in Fast5File.Fast5FileSet(args.files, group=args.group): fas = fast5.get_fastas(args.type) sizes.extend([len(fa.seq) for fa in fas if fa is not None]) fast5.close() if len(sizes) > 0: print "total reads\t%d" % (len(sizes)) print "total base pairs\t%d" % (sum(sizes)) print "mean\t%.2f" % (stat.mean(sizes)) print "median\t%d" % (stat.median(sizes)) print "min\t%d" % (min(sizes)) print "max\t%d" % (max(sizes)) nxvalues = stat.NX(sizes, [25,50,75]) print "N25\t%d" % (nxvalues[25]) print "N50\t%d" % (nxvalues[50]) print "N75\t%d" % (nxvalues[75]) else: logger.warning("No valid sequences observed.\n")
def indexEvolution_by_year(year): area_repo = AreaRepository(recreate_db=False, config=sqlite_config) indicator_repo = IndicatorRepository(recreate_db=False, config=sqlite_config) observation_repo = ObservationRepository(recreate_db=False, area_repo=area_repo, indicator_repo=indicator_repo, config=sqlite_config) index_indicator = indicator_repo.find_indicators_index()[0] observations = observation_repo.find_tree_observations(index_indicator.indicator, 'ALL', None, 'COMPONENT') areas = area_repo.find_countries(order="iso3") data = {'year': year, 'areas': OrderedDict(), 'stats': OrderedDict()} for area in sorted(areas, key=attrgetter('iso3')): for obs in sorted([obs for obs in observations if obs.area.iso3 == area.iso3], key=lambda o: o.indicator.indicator): if area.iso3 not in data['areas']: data['areas'][area.iso3] = OrderedDict() if obs.indicator.indicator not in data['areas'][area.iso3]: data['areas'][area.iso3][obs.indicator.indicator] = OrderedDict() if obs.year == int(year): data['areas'][area.iso3][obs.indicator.indicator]['value'] = obs.value if obs.indicator.type == 'INDEX': data['areas'][area.iso3][obs.indicator.indicator]['rank'] = obs.rank data['areas'][area.iso3][obs.indicator.indicator]['rank_change'] = obs.rank_change if obs.indicator.type == 'INDEX': if 'score_evolution' not in data['areas'][area.iso3][obs.indicator.indicator]: data['areas'][area.iso3][obs.indicator.indicator]['score_evolution'] = [] # data['areas'][area.iso3][obs.indicator.indicator]['value_evolution'] = [] data['areas'][area.iso3][obs.indicator.indicator]['score_evolution'].append( {'year': obs.year, 'value': obs.value}) # data['areas'][area.iso3][obs.indicator.indicator]['value_evolution'].append( # {'year': obs.year, 'value': obs.value}) # Clean areas without data that year for area in list(data['areas'].keys()): if 'value' not in data['areas'][area]['ODB']: del data['areas'][area] for indicator_code in sorted(set([o.indicator.indicator for o in observations])): per_indicator_obs = [o.value for o in observations if o.indicator.indicator == indicator_code and o.value is not None] if indicator_code not in data['stats']: data['stats'][indicator_code] = OrderedDict() data['stats'][indicator_code][':::'] = OrderedDict() data['stats'][indicator_code][':::']['mean'] = statistics.mean(per_indicator_obs) data['stats'][indicator_code][':::']['median'] = statistics.median(per_indicator_obs) for region in area_repo.find_regions(): per_region_obs = [o.value for o in observations if o.indicator.indicator == indicator_code and o.value is not None and o.area.iso3 in [c.iso3 for c in region.countries]] data['stats'][indicator_code][region.iso3] = OrderedDict() data['stats'][indicator_code][region.iso3]['mean'] = statistics.mean(per_region_obs) data['stats'][indicator_code][region.iso3]['median'] = statistics.median(per_region_obs) return json_response_ok(request, data)
def caculation(data): trt_1 = data[data['trt'] == 1] trt_0 = data[data['trt'] == 0] medi = statistics.median(trt_1['y']) - statistics.median(trt_0['y']) mean = statistics.mean(trt_1['y']) - statistics.mean(trt_0['y']) peop = len(trt_1) + len(trt_0) vari = statistics.variance(trt_1['y']) + statistics.variance(trt_0['y']) z_stat, p_val = stats.ranksums(trt_0['y'], trt_1['y']) return [medi, mean, peop, p_val]
def median_fn(srs): a=[x for x in srs.pop()] if len(a)%2: srs.push(a[len(a)//2]) else: if all([isinstance(x, str) for x in a[len(a)//2-1:][:2]]): med = median(map(ord,a)) srs.push(chr(int(med))) else: srs.push(median(a))
def getMedianAverageCenterIndexOfJongmokGroup(jongmokgroup): coll주식종목Data = pymongo.MongoClient('localhost', 27017).get_database("xadb").get_collection("주식종목Data") dictdictdictret = {} listproj = ["PER", "PBR", "EPS", "ROA", "ROE", "EVEBITDA", "SPS","CPS","BPS","PEG"] #make the project for find_one() dictproj ={} for proj in listproj : dictproj[proj] = 1 dictproj["_id"] = 0 for keygroup in jongmokgroup : print("making median, average,.. of %s"%keygroup) listjongmokhan = jongmokgroup[keygroup] # dictproj = {"PER":1, "PBR":1, "EPS":1, "ROA":1, "ROE":1, "EVEBITDA":1, "SPS":1,"CPS":1,"BPS":1,"PEG":1, "_id":0} listPER = [] listPBR = [] listEPS = [] listROA = [] listROE = [] listEVEBITDA = [] listSPS = [] listCPS = [] listBPS = [] listPEG = [] for jongmokhan in listjongmokhan : dictcondi = {'종목명':jongmokhan } objret = coll주식종목Data.find_one(dictcondi, dictproj) if objret == None: continue listPER.append(objret["PER"]) listPBR.append(objret["PBR"]) listEPS.append(objret["EPS"]) listROA.append(objret["ROA"]) listROE.append(objret["ROE"]) listEVEBITDA.append(objret["EVEBITDA"]) listSPS.append(objret["SPS"]) listCPS.append(objret["CPS"]) listBPS.append(objret["BPS"]) listPEG.append(objret["PEG"]) dictdictdictret[keygroup] = \ {"PER":{"min":min(listPER), "max":max(listPER), "median":stat.median(listPER), "mean":stat.mean(listPER), "stdev":stat.stdev(listPER, stat.mean(listPER))}, "PBR":{"min":min(listPBR), "max":max(listPBR), "median":stat.median(listPBR), "mean":stat.mean(listPBR), "stdev":stat.stdev(listPBR, stat.mean(listPBR))}, "EPS":{"min":min(listEPS), "max":max(listEPS), "median":stat.median(listEPS), "mean":stat.mean(listEPS), "stdev":stat.stdev(listEPS, stat.mean(listEPS))}, "ROA":{"min":min(listROA), "max":max(listROA), "median":stat.median(listROA), "mean":stat.mean(listROA), "stdev":stat.stdev(listROA, stat.mean(listROA))}, "ROE":{"min":min(listROE), "max":max(listROE), "median":stat.median(listROE), "mean":stat.mean(listROE), "stdev":stat.stdev(listROE, stat.mean(listROE))}, "EVEBITDA":{"min":min(listEVEBITDA), "max":max(listEVEBITDA), "median":stat.median(listEVEBITDA), "mean":stat.mean(listEVEBITDA), "stdev":stat.stdev(listEVEBITDA, stat.mean(listEVEBITDA))}, "SPS":{"min":min(listSPS), "max":max(listSPS), "median":stat.median(listSPS), "mean":stat.mean(listSPS), "stdev":stat.stdev(listSPS, stat.mean(listSPS))}, "CPS":{"min":min(listCPS), "max":max(listCPS), "median":stat.median(listCPS), "mean":stat.mean(listCPS), "stdev":stat.stdev(listCPS, stat.mean(listCPS))}, "BPS":{"min":min(listBPS), "max":max(listBPS), "median":stat.median(listBPS), "mean":stat.mean(listBPS), "stdev":stat.stdev(listBPS, stat.mean(listBPS))}, "PEG":{"min":min(listPEG), "max":max(listPEG), "median":stat.median(listPEG), "mean":stat.mean(listPEG), "stdev":stat.stdev(listPEG, stat.mean(listPEG))} } return dictdictdictret, listproj, ["min", "max", "median", "mean", "stdev"]
def grid_detect(rt): global inter_count avg_w = statistics.median([s[1][0] for s in rt]) avg_h = statistics.median([s[1][1] for s in rt]) merp={} for r in rt: # n coll = place_rect(r,avg_w*3,avg_h*3, merp) if coll is not None: return coll #print(inter_count) return None
def store_data(filename, results, iters): import statistics results_sorted = sorted(results) file = open(filename, 'w+') for f in results_sorted: file.write('-' * 20 + '\n') file.write(f + '\n') file.write('Iters: ' + str(statistics.median(iters[f])) + '\n') file.write(str(statistics.median(results[f]))+ '\n') file.write('-' * 20+ '\n') file.close()
def on_frame(self, controller): frame = controller.frame() previous = controller.frame(1) #The previous frame for hand in frame.hands: handType = "Left Hand" if hand.is_left else "Right Hand" linear_hand_movement = hand.translation(previous) LocationGlobalRelativeLeap=linear_hand_movement #print handType + " Hand ID: " + str(hand.id) + " Palm Position: " + str(hand.palm_position) normal = hand.palm_normal direction = hand.direction print LocationGlobalRelativeLeap.x print LocationGlobalRelativeLeap.y print LocationGlobalRelativeLeap.z print "" global x global y global z x=float(LocationGlobalRelativeLeap.x) xData.append(x) z=float(LocationGlobalRelativeLeap.y) zData.append(z) y=float(LocationGlobalRelativeLeap.z) yData.append(y) x=statistics.median(xData) y=statistics.median(yData) z=statistics.median(zData) if abs(x)>abs(y) and abs(x)>abs(z): x=x y=0 z=0 elif abs(y)>abs(x) and abs(y)>abs(z): y=y x=0 z=0 elif abs(z)>abs(x) and abs(z)>abs(y): z=z x=0 y=0 else: x=0 y=0 z=0 return x return y return z print x, y, z
def detect_breaks(self): _,thr = cv2.threshold(self.gray,214,255,cv2.THRESH_BINARY) _,con,_ = cv2.findContours(thr,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE) squares=[c for c in con if self._contour_is_square(c) and cv2.contourArea(c)>=16] if not squares: return ([],[]) a=statistics.median(cv2.contourArea(c) for c in squares) p=statistics.median(cv2.arcLength(c,True) for c in squares) blanks=[c for c in con if abs(cv2.contourArea(c)-a)<.1*a and abs(cv2.arcLength(c,True)-p)<.05*p] dist=int(p/8) yc = sorted({c[0,1] for s in blanks for c in s}) xc = sorted({c[0,0] for s in blanks for c in s}) return (self._squares_to_breaks(yc,dist),self._squares_to_breaks(xc,dist))
def without_outliers(iterator): # # Discard major outliers # (Explanation from: http://www.wikihow.com/Calculate-Outliers) # numbers = [i for i in iterator if i > 0] q2 = statistics.median(numbers) q1 = statistics.median(n for n in numbers if n < q2) q3 = statistics.median(n for n in numbers if n > q2) interquartile = q3 - q1 inner_offset = interquartile * 1.5 # inner fence; use 3.0 for outer fence lower_fence, higher_fence = q1 - inner_offset, q3 + inner_offset return [n for n in numbers if lower_fence <= d <= higher_fence]
def write_result_by_sim_params(sim_params, problem_params, simulations, file_obj): # Planner Model CoC to_write = "{}\t{}\t{}".format(sim_params.planner.name, sim_params.model.__name__, sim_params.coc) # Problem Params: boardx, y, num_soil, num_rocks, rand_range, a_prob for p in problem_params.get_params(): to_write += '\t{}'.format(p) # Avg Cost avg_cost = sum([sim.get_total_cost() for sim in simulations])/len(simulations) to_write += '\t' + str(avg_cost) # Median Cost md_cost = statistics.median([sim.get_total_cost() for sim in simulations]) to_write += '\t' + str(md_cost) # Num Problems Avged to_write += '\t' + str(len(simulations)) # Other misc: average observations made; avg messages sent; avg steps take; useful for comparing board-sizes avg_obs = 1.0 * sum([s.total_observations() for s in simulations])/len(simulations) to_write += '\t' + str(avg_obs) avg_msg_sent = 1.0 * sum([s.total_messages_sent() for s in simulations])/len(simulations) to_write += '\t' + str(avg_msg_sent) avg_msg_void = 1.0 * sum([s.total_messages_voided() for s in simulations])/len(simulations) to_write += '\t' + str(avg_msg_void) avg_steps = 1.0 * sum([s.total_steps() for s in simulations])/len(simulations) to_write += '\t' + str(avg_steps) # Other misc: medians # Other misc: average observations made; avg messages sent; avg steps take; useful for comparing board-sizes avg_obs = 1.0 * statistics.median([s.total_observations() for s in simulations]) to_write += '\t' + str(avg_obs) avg_msg_sent = 1.0 * statistics.median([s.total_messages_sent() for s in simulations]) to_write += '\t' + str(avg_msg_sent) avg_msg_void = 1.0 * statistics.median([s.total_messages_voided() for s in simulations]) to_write += '\t' + str(avg_msg_void) avg_steps = 1.0 * statistics.median([s.total_steps() for s in simulations]) to_write += '\t' + str(avg_steps) file_obj.write(to_write + '\n') file_obj.flush()
def get_sensor_data(self): Tools.log("Buffer:" + str(self.sensor_buffer)) try: sensor_data = {"sensors": {}, "recordTimestamp": {}} sensor_data["sensors"]["flow"] = sum(self.sensor_buffer["flow"]) sensor_data["sensors"]["sound"] = statistics.median(self.sensor_buffer["sound"]) sensor_data["sensors"]["ultrasonic"] = statistics.median(self.sensor_buffer["ultrasonic"]) sensor_data["sensors"]["temp"] = statistics.mean(self.sensor_buffer["temp"]) sensor_data["sensors"]["humidity"] = statistics.mean(self.sensor_buffer["humidity"]) sensor_data["recordTimestamp"] = Tools.now_int_epoch() Tools.log("Data to send:" + str(sensor_data)) GLOBALS["errorCount"] -= 0.5 except Exception, e: Tools.log("Error caculating data: %s" % str(e), 1)
def write_profile(profile_f, dependents, profile, batch_size): profile_f.write("Extracting {0} values:\n".format(len(dependents))) for dependent in dependents: profile_f.write("* `{0}`\n".format(dependent)) profile_f.write("\n".format(batch_size)) profile_f.write("Batch size: {0}\n\n".format(batch_size)) table = tabulate( [('batch_extractions', len(profile['per_batch_duration'])), ('total_time', round(sum(profile['per_batch_duration']), 3)), ('min_time', round(min(profile['per_batch_duration']), 3)), ('max_time', round(max(profile['per_batch_duration']), 3)), ('mean_time', round(mean(profile['per_batch_duration']), 3)), ('median_time', round(median(profile['per_batch_duration']), 3))], headers=["stat", "value"], tablefmt="pipe" ) profile_f.write(table + "\n\n") del profile['per_batch_duration'] feature_profiles = [] datasource_profiles = [] misc_profiles = [] for dependent_name, durations in profile.items(): row = (dependent_name.replace("<", "\<").replace(">", "\>"), len(durations), round(min(durations), 3), round(max(durations), 3), round(mean(durations), 3), round(median(durations), 3)) if "feature." in dependent_name: feature_profiles.append(row) elif "datasource." in dependent_name: datasource_profiles.append(row) else: misc_profiles.append(row) if len(feature_profiles) > 0: profile_f.write("# Features\n") write_dependent_profiles(profile_f, feature_profiles) if len(datasource_profiles) > 0: profile_f.write("# Datasources\n") write_dependent_profiles(profile_f, datasource_profiles) if len(misc_profiles) > 0: profile_f.write("# Misc\n") write_dependent_profiles(profile_f, misc_profiles)
def filter_outliers(data, stdev_factor=2.5): #stdev_factor - how many stdevs from the median is still legit if not data: #empty return data med = statistics.median(data) #filter extreme outliers error = [abs(x-med) for x in data] max_error = statistics.median(error)*5 #5 seems like enough data = [x for x in data if abs(x-med) < max_error] #filter outliers if len(data) > 1: #statistics.stdev only works for two or more elements stdev = statistics.stdev(data) return [v for v in data if abs(med-v) < stdev_factor*stdev] else: return data
def cleanup(G, descript, algo_directed, algo_simple): ''' GRAPH Cleaning: Sometimes the graphs need to be cleaned for certain type of algorithms. The idea here is that we are trying to best match the data to what the algorithm can do. We start with specific matches and work our way to more general. ''' #first we check if algo and data have same directedness and type. if G.is_directed() == algo_directed and G.is_simple() == algo_simple: print("\t[Info - ", descript, "] - No graph cleaning required directed: ", algo_directed, " simple: ", algo_simple) weight_attr = "weight" if G.is_weighted() else None return G, weight_attr collapsed = False directed_graph = G.is_directed() if algo_directed and not G.is_directed(): print("\t[Info - ", descript, "] - Warning: Passing undirected graph to directed algo") #otherwise we need to make some mods to the graph, so we will copy it then make the mods G_copy = G.copy() #if the graph is directed and algo is not directed if G.is_directed() and not algo_directed: #can't collapse on weight without first making sure the edges are weighted #In this case, we just give each edge a weight of 1 if not G_copy.is_weighted(): G_copy.es()['weight'] = 1 #here we make the actual conversion G_copy.to_undirected(combine_edges={'weight':sum}) print('\t[Info - ',descript,'] Converting graph to undirected (summing edge weights)') collapsed = True #if the algo is simple but the data is not, then we have to make the data simple if algo_simple and not G.is_simple(): #can't collapse on weight without first making sure the edges are weighted if not G.is_weighted(): G_copy.es()['weight'] = 1 G_copy.simplify(combine_edges={'weight':sum}) print('\t[Info - ',descript,'] Collapsed multigraph edges (summing edge weights)') collapsed = True if collapsed == True: weights = G_copy.es()['weight'] #print("MEDIAN: ", statistics.median(weights), " MAX: ", max(weights)) threshold = statistics.median(weights) orig_edge_len = G_copy.ecount() edges = G_copy.es.select(weight_lt=threshold) G_copy.delete_edges(edges) print("\t[Info - ", descript,"] Pruned ", len(edges)," of ",orig_edge_len," edges less than weight of ", threshold) #if the graph is collapsed, I think it becomes undirected directed_graph = False #we could do this outside the function, but it makes it cleaner this way weights_attr = "weight" if G_copy.is_weighted() else None return G_copy, weights_attr
def async_update(self): """Get the latest data and updates the states.""" if self._max_age is not None: self._purge_old() if not self.is_binary: try: # require only one data point self.mean = round(statistics.mean(self.states), 2) self.median = round(statistics.median(self.states), 2) except statistics.StatisticsError as err: _LOGGER.error(err) self.mean = self.median = STATE_UNKNOWN try: # require at least two data points self.stdev = round(statistics.stdev(self.states), 2) self.variance = round(statistics.variance(self.states), 2) except statistics.StatisticsError as err: _LOGGER.error(err) self.stdev = self.variance = STATE_UNKNOWN if self.states: self.count = len(self.states) self.total = round(sum(self.states), 2) self.min = min(self.states) self.max = max(self.states) self.change = self.states[-1] - self.states[0] self.average_change = self.change if len(self.states) > 1: self.average_change /= len(self.states) - 1 if self._max_age is not None: self.max_age = max(self.ages) self.min_age = min(self.ages) else: self.min = self.max = self.total = STATE_UNKNOWN self.average_change = self.change = STATE_UNKNOWN
def print_stats(l): # noqa: C901 try: print("\tMean: {}".format(mean(l))) except StatisticsError as e: print("\tMean: {}".format(str(e))) try: print("\tMedian: {}".format(median(l))) except StatisticsError as e: print("\tMedian: {}".format(str(e))) try: print("\tMode: {}".format(mode(l))) except StatisticsError as e: print("\tMode: {}".format(str(e))) try: print("\tMax: {}".format(max(l))) except StatisticsError as e: print("\tMax: {}".format(str(e))) try: print("\tMin: {}".format(min(l))) except StatisticsError as e: print("\tMin: {}".format(str(e)))
if went_in_progress(jDetails): prgDate = jrn.created_on #print("Went in progress: " + str(prgDate)) break leadTime = endDate - crtDate #print("Lead time " + str(leadTime)) leadList.append(leadTime.days) if prgDate: cycTime = endDate - prgDate #print("Cycle time: " + str(cycTime)) cycleList.append(cycTime.days) meanCycTime = statistics.mean(cycleList) medianCycTime = statistics.median(cycleList) meanLeadTime = statistics.mean(leadList) medianLeadTime = statistics.median(leadList) print("Mean cycle time: " + str(meanCycTime)) print("Median cycle time: " + str(medianCycTime)) print("Minimum cycle time: " + str(min(cycleList))) print("Maximum cycle time: " + str(max(cycleList))) print("Mean lead time: " + str(meanLeadTime)) print("Median lead time: " + str(medianLeadTime)) print("Minimum lead time: " + str(min(leadList))) print("Maximum lead time: " + str(max(leadList))) print("Amount of tickets: " + str(len(u_tickets)))
# this formatter will label the colorbar with the correct target names formatter = plt.FuncFormatter(lambda i, *args: iris.target_names[int(i)]) plt.figure(figsize=(5, 4)) plt.scatter(iris.data[:, x_index], iris.data[:, y_index], c=iris.target) plt.colorbar(ticks=[0, 1, 2], format=formatter) plt.xlabel(iris.feature_names[x_index]) plt.ylabel(iris.feature_names[y_index]) plt.tight_layout() plt.show() # Medidas import statistics from scipy import stats as st media = statistics.mean(x) media2 = sum(x) / len(x) mediana = statistics.median(x) amplitude = max(x) - min(x) variancia = statistics.variance(x) desvio_padrao = statistics.stdev(x) coeficente_variacao = st.variation(x) # Quartil q1 = np.quantile(x, 0.25) q2 = np.quantile(x, 0.50) q3 = np.quantile(x, 0.75) # Boxplot plt.title('Boxplot') plt.boxplot(x, vert=False) plt.show()
import statistics t = int(input()) for _ in range(t): n = int(input()) arr = list(map(int, input().split())) b = [arr[0], arr[1], arr[2]] while len(arr) != 2: arr.remove(statistics.median(b)) if len(arr) == 2: break b = [arr[0], arr[1], arr[2]] print(arr[0], arr[1])
def loop(self): num_reqs = 0 bad_calls = 0 start = time.time() res_time = [] # Print some bullshit print("Testing {0}".format(self.uri)) print( "{0} seconds between requests with a maximum of {1} loops.".format( self.sleep, self.limit)) if not self.asyncr: print("Running in non-asyncronous request mode.\n") if self.asyncr: print("Running in asyncronous mode.\n") while True: try: if not self.asyncr: num_reqs += 1 # fire off the request try: response_timer_init = time.time() req = requests.get(self.uri) response_timer_quit = (time.time() - response_timer_init) res_time.append(response_timer_quit) # return request if req.status_code != requests.codes.ok: bad_calls += 1 print(".", end=" ", flush=True) # Back off if requested by the --sleep option if int(self.sleep) > 0: time.sleep(int(self.sleep)) # Kill after the number of loops has been exceeded. if int(self.limit) > 0: if int(num_reqs) == int(self.limit): raise ValueError except requests.exceptions.ConnectionError: print( "Cannot find a website listening at {0} on port {1}. Aborting." .format(self.uri, "0")) break if self.asyncr: try: raise NotImplementedError except NotImplementedError: print( "Sorry. Async mode hasn't been implemented yet. Bad dev! No biscuit!" ) sys.exit(1) except (KeyboardInterrupt, ValueError): print("\n\nReceived interrupt. Quitting.") # Post analysis end = (time.time() - start) print( "Made {0} requests to {1} in {2} seconds with {3} bad status codes\n" .format(num_reqs, self.uri, end, bad_calls)) # Some stats print("Statistics:") print("===========") print("{0:<22}: {1:<18} seconds".format( "Average response time", statistics.mean(res_time))) print("{0:<22}: {1:<18} seconds".format( "Median response time", statistics.median(res_time))) print("{0:<22}: {1:<18} seconds".format( "Fastest response time", min(res_time))) print("{0:<22}: {1:<18} seconds\n".format( "Slowest response time", max(res_time))) # Show headers if the option has been set if self.headers: headers.Headers(self.uri).lookup() # Show DNS info if the option has been set if self.dnsinfo: dnskit.DNS(self.uri).lookup() # Show IP info if the option has been set if self.ipinfo: ipinfo.IPInfo(self.uri).lookup() print("") sys.exit(0)
''' Created on May 22, 2018 @author: berag ''' if __name__ == '__main__': pass import statistics as st print(st.mean([1, 2, 5, 9, 4, 3])) #4 print(st.median([1, 2, 5, 4])) #3.0 print(11 // 2) #5 print(11.0 // 2) #5.0 print(.1 + .1 + .1) # Not .3 its 0.30000000000000004 # https://docs.python.org/3/tutorial/floatingpoint.html print(1 / 10) #0.1 print("I think you\'re Super Hero") #print("String" / 2) #TypeError: unsupported operand type(s) for /: 'str' and 'int'
def full_comparision(dataset_names, all_datasets, showplot=False, random_seed=None, new_header=True, xerr=0, yerr=0.1, save_models=True): res_df = pd.DataFrame() returned_models = dict() figures = [] for dataset_name in dataset_names: problem_type, downsample_size, max_rules, realkd_reg, max_col_attr, rulefit_reg,\ test_size, repeats, pos_class, opt_max_rules = \ all_datasets[dataset_name] (min_Cs, max_Cs, no_Cs) = rulefit_reg (greedy_reg, opt_reg) = realkd_reg rulefit_aucs_test = [] rulefit_aucs_train = [] realkd_greedy_aucs_test = [] realkd_greedy_aucs_train = [] realkd_optimal_aucs_test = [] realkd_optimal_aucs_train = [] seeds = [] for rep in range(repeats): random_seed = generate_random_seed() if ( (random_seed is None) or (repeats != 1)) else random_seed seeds.append(random_seed) rulefit_fixed = { 'dataset_name': dataset_name, 'model_class': 'rulefit', 'objective': 'classify' if problem_type == 'c' else 'regress', 'metrics': ['roc_auc'] if problem_type == 'c' else ['r2'], 'downsample_size': downsample_size, 'seed': random_seed, 'test_size': test_size, 'pos_class': pos_class } realkd_fixed = { 'dataset_name': dataset_name, 'model_class': 'realkd', 'objective': 'logistic' if problem_type == 'c' else 'squared', 'metrics': ['roc_auc'] if problem_type == 'c' else ['r2'], 'downsample_size': downsample_size, 'seed': random_seed, 'test_size': test_size, 'pos_class': pos_class } realkd_greedy_params = { 'max_rules': max_rules, 'reg': greedy_reg, 'max_col_attr': max_col_attr, 'method': 'greedy', 'offset_rule': False } realkd_opt_params = { 'max_rules': max_rules if opt_max_rules is None else opt_max_rules, 'reg': opt_reg, 'max_col_attr': max_col_attr, 'method': 'bestboundfirst', 'offset_rule': False } Cs_lst = np.linspace(min_Cs, max_Cs, no_Cs, endpoint=True) Cs_lst = [np.array([Cs_lst[i]]) for i in range(len(Cs_lst))] rulefit_params_lst = [{ 'Cs': Cs, 'random_state': random_seed } for Cs in Cs_lst] (rulefit_x_test, rulefit_y_test), (rulefit_x_train, rulefit_y_train), rulefit_time,\ rulefit_rule_length, best_rulefit = \ rulefit_sweep(rulefit_fixed, rulefit_params_lst, max_rules) rulefit_auc_test = np.trapz(rulefit_y_test, rulefit_x_test) / ( max(rulefit_x_test) - min(rulefit_x_test) ) # + int(problem_type == 'c')) rulefit_auc_train = np.trapz(rulefit_y_train, rulefit_x_train) / ( max(rulefit_x_train) - min(rulefit_x_train) ) # + int(problem_type == 'c')) rulefit_aucs_test.append(rulefit_auc_test) rulefit_aucs_train.append(rulefit_auc_train) best_rulefit_rules = best_rulefit.get_rules() best_rulefit_rules = best_rulefit_rules[ best_rulefit_rules.coef != 0].sort_values("support", ascending=False) for idx, rule in best_rulefit_rules.iterrows(): print(('+' if rule['coef'] > 0 else '') + str(rule['coef']) + ' if ' + rule['rule']) for i in range(len(rulefit_x_test)): print(rulefit_x_test[i], rulefit_y_test[i]) print(rulefit_auc_test) greedy_exp = Experiment(**realkd_fixed, params=realkd_greedy_params) realkd_greedy_df, greedy_model = greedy_exp.run() greedy_rule_length = sum(greedy_exp.results['rule_lengths']) / len( greedy_exp.results['rule_lengths']) len_vs_perf_greedy_test = greedy_exp.results[ realkd_fixed['metrics'][0] + '_length_vs_perf' + '_test'][int(problem_type == 'r'):] len_vs_perf_greedy_train = greedy_exp.results[ realkd_fixed['metrics'][0] + '_length_vs_perf' + '_train'][int(problem_type == 'r'):] print(len_vs_perf_greedy_test) realkd_greedy_auc_test = np.trapz( len_vs_perf_greedy_test.values, len_vs_perf_greedy_test.index) / (max_rules - int(problem_type == 'r')) realkd_greedy_auc_train = np.trapz( len_vs_perf_greedy_train.values, len_vs_perf_greedy_train.index) / (max_rules - int(problem_type == 'r')) realkd_greedy_aucs_test.append(realkd_greedy_auc_test) realkd_greedy_aucs_train.append(realkd_greedy_auc_train) print(realkd_greedy_auc_test) opt_exp = Experiment(**realkd_fixed, params=realkd_opt_params) realkd_opt_df, opt_model = opt_exp.run() len_vs_perf_opt_test = opt_exp.results[realkd_fixed['metrics'][0] + '_length_vs_perf' + '_test'][int( problem_type == 'r'):] len_vs_perf_opt_train = opt_exp.results[realkd_fixed['metrics'][0] + '_length_vs_perf' + '_train'][int( problem_type == 'r'):] while len_vs_perf_opt_test.index[-1] < max_rules: len_vs_perf_opt_test.loc[len_vs_perf_opt_test.index[-1] + 1] = len_vs_perf_opt_test.values[-1] len_vs_perf_opt_train.loc[len_vs_perf_opt_train.index[-1] + 1] = len_vs_perf_opt_train.values[-1] print(len_vs_perf_opt_test) realkd_opt_auc_test = np.trapz( len_vs_perf_opt_test.values, len_vs_perf_opt_test.index) / ( max_rules - int(problem_type == 'r')) realkd_opt_auc_train = np.trapz( len_vs_perf_opt_train.values, len_vs_perf_opt_train.index) / ( max_rules - int(problem_type == 'r')) realkd_optimal_aucs_test.append(realkd_opt_auc_test) realkd_optimal_aucs_train.append(realkd_opt_auc_train) print(realkd_opt_auc_test) opt_rule_length = sum(opt_exp.results['rule_lengths']) / len( opt_exp.results['rule_lengths']) plt.errorbar(rulefit_x_test, rulefit_y_test, xerr=[xerr for x in rulefit_x_test], yerr=[yerr for y in rulefit_y_test], fmt='+', ecolor='b', label='rulefit') plt.plot(rulefit_x_test, rulefit_y_test, 'b-') plt.errorbar(len_vs_perf_greedy_test.index, len_vs_perf_greedy_test.values, xerr=[xerr for x in len_vs_perf_greedy_test], yerr=[yerr for y in len_vs_perf_greedy_test], fmt='+', ecolor='r', label='realkd_greedy') plt.plot(len_vs_perf_greedy_test.index, len_vs_perf_greedy_test.values, 'r-') plt.errorbar(len_vs_perf_opt_test.index, len_vs_perf_opt_test.values, xerr=[xerr for x in len_vs_perf_opt_test], yerr=[yerr for y in len_vs_perf_opt_test], fmt='+', ecolor='g', label='realkd_opt') plt.plot(len_vs_perf_opt_test.index, len_vs_perf_opt_test.values, 'g-') plt.xlabel('number of rules') plt.ylabel('roc_auc' if problem_type == 'c' else 'r2') plt.title(dataset_name) plt.legend() if save_models: to_save = [(None, realkd_fixed), (opt_model, realkd_opt_params), (greedy_model, realkd_greedy_params), (None, rulefit_fixed), (best_rulefit, { 'params': rulefit_params_lst })] save_dir = save_three_models(dataset_name, random_seed, to_save) plt.savefig( os.path.join(save_dir, 'comparison_plot' + str(rep))) if showplot: plt.show() res_dict = { 'dataset': dataset_name, 'problem_type': problem_type, 'no_feat': int(realkd_opt_df['no_feat']), 'no_rows': int(realkd_opt_df['no_rows']), 'max_rules': max_rules, 'rulefit_auc_test': rulefit_auc_test, 'rulefit_auc_train': rulefit_auc_train, 'rulefit_reg': rulefit_reg, 'rulefit_time': rulefit_time, 'rulefit_rule_length': rulefit_rule_length, 'greedy_auc_test': realkd_greedy_auc_test, 'greedy_auc_train': realkd_greedy_auc_train, 'greedy_reg': greedy_reg, 'greedy_time': greedy_exp.fit_time, 'greedy_rule_length': greedy_rule_length, 'opt_auc_test': realkd_opt_auc_test, 'opt_auc_train': realkd_opt_auc_train, 'opt_reg': opt_reg, 'opt_max_rules': opt_max_rules, 'opt_time': opt_exp.fit_time, 'opt_rule_length': opt_rule_length, 'random_seed': random_seed, 'model_dir': save_dir if save_models else None, 'rulefit_len_v_perf_test': [rulefit_x_test, rulefit_y_test], 'rulefit_len_v_perf_train': [rulefit_x_train, rulefit_y_train], 'greedy_len_v_perf_test': [ len_vs_perf_greedy_test.index, len_vs_perf_greedy_test.values ], 'greedy_len_v_perf_train': [ len_vs_perf_greedy_train.index, len_vs_perf_greedy_train.values ], 'opt_len_v_perf_test': [len_vs_perf_opt_test.index, len_vs_perf_opt_test.values], 'opt_len_v_perf_train': [len_vs_perf_opt_train.index, len_vs_perf_opt_train.values] } fieldnames_all_runs = res_dict.keys() with open('new_results_table.csv', 'a') as f: #datasets_perf_all_runs all_res_csv_writer = DictWriter(f, fieldnames=fieldnames_all_runs) if new_header: all_res_csv_writer.writeheader() new_header = False all_res_csv_writer.writerow(res_dict) dataset_results = pd.Series({ 'dataset': dataset_name, 'problem_type': problem_type, 'no_feat': int(realkd_opt_df['no_feat']), 'no_rows': int(realkd_opt_df['no_rows']), 'rulefit_auc_test': median(rulefit_aucs_test), 'rulefit_auc_train': median(rulefit_aucs_train), 'rulefit_reg': rulefit_reg, 'realkd_greedy_auc_test': median(realkd_greedy_aucs_test), 'realkd_greedy_auc_train': median(realkd_greedy_aucs_train), 'greedy_reg': greedy_reg, 'realkd_optimal_auc_test': median(realkd_optimal_aucs_test), 'realkd_optimal_auc_train': median(realkd_optimal_aucs_train), 'optimal_reg': opt_reg, 'random_seeds': seeds }) print(dataset_results) # res_df = res_df.append(dataset_results, ignore_index=True) returned_models[dataset_name] = { 'rulefit': best_rulefit, 'greedy': greedy_model, 'optimal': opt_model } ''' fieldnames = res_df.columns with open('datasets_perf.csv', 'w') as f: csv_writer = DictWriter(f, fieldnames=fieldnames) csv_writer.writeheader() for idx, row in res_df.iterrows(): csv_writer.writerow(row.to_dict()) ''' return returned_models
def rulefit_sweep(fixed_params, variable_lst, max_rules): test_res_vect = [] train_res_vect = [] best_rulefit = None best_rulefit_score = None fit_times = [] max_fitted_rules = 0 rule_lengths = [] for params in variable_lst: print(params) fixed_params['params'] = params metric = fixed_params['metrics'][0] exp = Experiment(**fixed_params) res, model = exp.run() rule_lengths += exp.results['rule_lengths'] if (best_rulefit == None) or ( (exp.results[metric + '_test'][1] > best_rulefit_score) and (exp.results[metric + '_test'][0] <= max_rules)): best_rulefit = model best_rulefit_score = exp.results[metric + '_test'][1] no_rules = exp.results[metric + '_test'][0] if no_rules > max_fitted_rules: max_fitted_rules = no_rules fit_times.append((no_rules, exp.fit_time)) print(exp.results[metric + '_test'], exp.results[metric + '_train']) test_res_vect.append(exp.results[metric + '_test']) train_res_vect.append(exp.results[metric + '_train']) average_rule_length = sum(rule_lengths) / len(rule_lengths) fit_times.sort() filtered_fit_times = list( filter(lambda item: item[0] == max_fitted_rules, fit_times)) fit_times = [item[1] for item in filtered_fit_times] average_fit_time = sum(fit_times) / len(fit_times) test_res_vect = list( filter(lambda item: item[0] <= max_rules, test_res_vect)) train_res_vect = list( filter(lambda item: item[0] <= max_rules, train_res_vect)) if fixed_params['objective'] == 'regress': test_res_vect = list(filter(lambda item: item[0] > 0, test_res_vect)) train_res_vect = list(filter(lambda item: item[0] > 0, train_res_vect)) test_res_vect.sort(key=lambda item: item[0]) train_res_vect.sort(key=lambda item: item[0]) x, y = zip(*test_res_vect) x2, y2 = zip(*train_res_vect) x, x2 = list(x), list(x2) y, y2 = list(y), list(y2) xy_dict, xy_dict2 = dict(), dict() for i in range(len(x)): x_key = str(x[i]) if x_key in xy_dict: xy_dict[x_key].append(y[i]) else: xy_dict[x_key] = [y[i]] x_key = str(x2[i]) if x_key in xy_dict2: xy_dict2[x_key].append(y2[i]) else: xy_dict2[x_key] = [y2[i]] x_keys = xy_dict.keys() x_keys2 = xy_dict2.keys() x, x2 = [], [] y, y2 = [], [] for key in x_keys: x.append(int(key)) y.append(median(xy_dict[key])) for key in x_keys2: x2.append(int(key)) y2.append(median(xy_dict2[key])) while x[-1] < max_rules: x.append(x[-1] + 1) y.append(y[-1]) while x2[-1] < max_rules: x2.append(x2[-1] + 1) y2.append(y2[-1]) return (x, y), (x2, y2), average_fit_time, average_rule_length, best_rulefit
Est3 = abs3.T[248:253, ] Est4 = abs4.T[248:253, ] Est0CUA = Est0**2 Est1CUA = Est1**2 Est2CUA = Est2**2 Est3CUA = Est3**2 Est4CUA = Est4**2 NewEst0 = (sum(Est0CUA) / 5)**(1 / 2) NewEst1 = (sum(Est1CUA) / 5)**(1 / 2) NewEst2 = (sum(Est2CUA) / 5)**(1 / 2) NewEst3 = (sum(Est3CUA) / 5)**(1 / 2) NewEst4 = (sum(Est4CUA) / 5)**(1 / 2) Esp0 = stats.median(NewEst0) Esp1 = stats.median(NewEst1) Esp2 = stats.median(NewEst2) Esp3 = stats.median(NewEst3) Esp4 = stats.median(NewEst4) Sesgo0 = Esp0 - a0 Var0 = stats.variance(NewEst0) Sesgo1 = Esp1 - a0 Var1 = stats.variance(NewEst1) Sesgo2 = Esp2 - a0 Var2 = stats.variance(NewEst2) Sesgo3 = Esp3 - a0
def _salary_calculator(self): #---------------------------------------------------------------------- # Return appropriate salary group by salary value #---------------------------------------------------------------------- def _get_salary_group(salary): return { salary < 20000: 'Менее 20000', 20000 <= salary < 30000: '20000-30000', 30000 <= salary < 40000: '30000-40000', 40000 <= salary < 50000: '40000-50000', 50000 <= salary < 60000: '50000-60000', 60000 <= salary < 70000: '60000-70000', 70000 <= salary < 90000: '70000-90000', 90000 <= salary: 'Более 90000' }[True] sum = total = 0 salary_all = [] regions = [region[0] for region in self.regions] region_salary_dict = { 'average_salary': 0, 'median_salary': 0, 'modal_salary': 0, 'sum': 0, 'total': 0, 'salary_all': [], } self.salaries_by_region = { region: region_salary_dict for region in regions } for vacancy in self.vacancies: region = vacancy.get('area').get('name') if vacancy.get('salary'): salary = dict(vacancy['salary']) if salary.get('currency') == 'RUR': if salary.get('gross'): if salary.get('from'): salary['from'] = salary['from'] * 0.87 if salary.get('to'): salary['to'] = salary['to'] * 0.87 if salary.get('from'): self.salaries_by_region[region]['sum'] += salary.get( 'from') self.salaries_by_region[region]['total'] += 1 self.salaries_by_region[region]['salary_all'].append( salary.get('from')) self.salary_groups[_get_salary_group( int(salary.get('from')))] += 1 salary_all.append(salary.get('from')) sum += salary.get('from') total += 1 if salary.get('to'): self.salaries_by_region[region]['sum'] += salary.get( 'to') self.salaries_by_region[region]['total'] += 1 self.salaries_by_region[region]['salary_all'].append( salary.get('to')) self.salary_groups[_get_salary_group( int(salary.get('to')))] += 1 salary_all.append(salary.get('to')) sum += salary.get('to') total += 1 # Calculate median salary self.median_salary = statistics.median(salary_all) # Calculate average salary if total > 0: self.average_salary = round(sum / total) for region in regions: self.salaries_by_region[region]['median_salary'] = \ statistics.median(self.salaries_by_region[region]['salary_all']) if self.salaries_by_region[region]['total'] > 0: self.salaries_by_region[region]['average_salary'] = \ round(self.salaries_by_region[region]['sum'] \ / self.salaries_by_region[region]['total']) # Calculate modal salary for group, salary in self.salary_groups.items(): if salary == max(self.salary_groups.values()): self.modal_salary = group self.salaries = [('Средняя', self.average_salary), ('Медиана', self.median_salary), ('Модальная', self.modal_salary)]
if y_h_neg[j - 1] != y_target[j - 1]: Ein[1, j] = Ein[1, j - 1] + 1 else: Ein[1, j] = Ein[1, j - 1] - 1 Ein = Ein / data_size index = np.where(Ein == np.amin(Ein)) g_multi = [] for i in range(len(index[0])): if index[0][i] == 0: s = 1 else: s = -1 theta = thetaList[index[1][i]] g_multi.append(s + theta) g_min = np.where(g_multi == np.amin(g_multi)) theta = thetaList[index[1][g_min]] if index[0][g_min] == 0: # s = 1 Eout = (1 - 2 * Tau) * (abs(theta) / 2) + Tau else: # s = -1 Eout = (1 - 2 * Tau) * (1 - abs(theta) / 2) + Tau ans.append(Eout - np.amin(Ein)) t += 1 mean = sum(ans) / repeatTimes median = stat.median(ans) print("The mean is", mean) print("The median is", median)
def history_stats(parse_samples, start=None, verbose=False, context=None, history=None): """Fetch, parse, and compute ping and usage stats. Note: See module level docs regarding brackets in field names. Args: parse_samples (int): Number of samples to process, or -1 to parse all available samples. start (int): Optional starting counter value to be applied to the history data. See `history_bulk_data` documentation for more details on how this parameter is used. verbose (bool): Optionally produce verbose output. context (ChannelContext): Optionally provide a channel for reuse across repeated calls. history: Optionally provide the history data to use instead of fetching it, from a prior call to `get_history`. Returns: A tuple with 6 dicts, mapping general data names, ping drop stat names, ping drop run length stat names, ping latency stat names, loaded ping latency stat names, and bandwidth usage stat names to their respective values, in that order. Note: Additional dicts may be added to this tuple in the future with additional data groups, so it not recommended for the caller to assume exactly 6 elements. Raises: GrpcError: Failed getting history info from the Starlink user terminal. """ if history is None: try: history = get_history(context) except grpc.RpcError as e: raise GrpcError(e) sample_range, parsed_samples, current = _compute_sample_range( history, parse_samples, start=start, verbose=verbose) tot = 0.0 count_full_drop = 0 count_unsched = 0 total_unsched_drop = 0.0 count_full_unsched = 0 count_obstruct = 0 total_obstruct_drop = 0.0 count_full_obstruct = 0 second_runs = [0] * 60 minute_runs = [0] * 60 run_length = 0 init_run_length = None usage_down = 0.0 usage_up = 0.0 rtt_full = [] rtt_all = [] rtt_buckets = [[] for _ in range(15)] for i in sample_range: d = history.pop_ping_drop_rate[i] if d >= 1: # just in case... d = 1 count_full_drop += 1 run_length += 1 elif run_length > 0: if init_run_length is None: init_run_length = run_length else: if run_length <= 60: second_runs[run_length - 1] += run_length else: minute_runs[min((run_length - 1) // 60 - 1, 59)] += run_length run_length = 0 elif init_run_length is None: init_run_length = 0 tot += d down = history.downlink_throughput_bps[i] usage_down += down up = history.uplink_throughput_bps[i] usage_up += up rtt = history.pop_ping_latency_ms[i] # note that "full" here means the opposite of ping drop full if d == 0.0: rtt_full.append(rtt) if down + up > 500000: rtt_buckets[min(14, int(math.log2( (down + up) / 500000)))].append(rtt) else: rtt_buckets[0].append(rtt) if d < 1.0: rtt_all.append((rtt, 1.0 - d)) # If the entire sample set is one big drop run, it will be both initial # fragment (continued from prior sample range) and final one (continued # to next sample range), but to avoid double-reporting, just call it # the initial run. if init_run_length is None: init_run_length = run_length run_length = 0 def weighted_mean_and_quantiles(data, n): if not data: return None, [None] * (n + 1) total_weight = sum(x[1] for x in data) result = [] items = iter(data) value, accum_weight = next(items) accum_value = value * accum_weight for boundary in (total_weight * x / n for x in range(n)): while accum_weight < boundary: try: value, weight = next(items) accum_value += value * weight accum_weight += weight except StopIteration: # shouldn't happen, but in case of float precision weirdness... break result.append(value) result.append(data[-1][0]) accum_value += sum(x[0] for x in items) return accum_value / total_weight, result bucket_samples = [] bucket_min = [] bucket_median = [] bucket_max = [] for bucket in rtt_buckets: if bucket: bucket_samples.append(len(bucket)) bucket_min.append(min(bucket)) bucket_median.append(statistics.median(bucket)) bucket_max.append(max(bucket)) else: bucket_samples.append(0) bucket_min.append(None) bucket_median.append(None) bucket_max.append(None) rtt_all.sort(key=lambda x: x[0]) wmean_all, wdeciles_all = weighted_mean_and_quantiles(rtt_all, 10) rtt_full.sort() mean_full, deciles_full = weighted_mean_and_quantiles( tuple((x, 1.0) for x in rtt_full), 10) return { "samples": parsed_samples, "end_counter": current, }, { "total_ping_drop": tot, "count_full_ping_drop": count_full_drop, "count_obstructed": count_obstruct, "total_obstructed_ping_drop": total_obstruct_drop, "count_full_obstructed_ping_drop": count_full_obstruct, "count_unscheduled": count_unsched, "total_unscheduled_ping_drop": total_unsched_drop, "count_full_unscheduled_ping_drop": count_full_unsched, }, { "init_run_fragment": init_run_length, "final_run_fragment": run_length, "run_seconds[1,]": second_runs, "run_minutes[1,]": minute_runs, }, { "mean_all_ping_latency": wmean_all, "deciles_all_ping_latency[]": wdeciles_all, "mean_full_ping_latency": mean_full, "deciles_full_ping_latency[]": deciles_full, "stdev_full_ping_latency": statistics.pstdev(rtt_full) if rtt_full else None, }, { "load_bucket_samples[]": bucket_samples, "load_bucket_min_latency[]": bucket_min, "load_bucket_median_latency[]": bucket_median, "load_bucket_max_latency[]": bucket_max, }, { "download_usage": int(round(usage_down / 8)), "upload_usage": int(round(usage_up / 8)), }
while True: #落下判定 altitude_b = [] altitude_a = [] drop_synthetic_acc = [] for i in range(0, 5): altitude_b.append(press.altitude_cal()) drop_synthetic_acc.append(acc.synthetic_acc_cal()) for j in range(0, 5): altitude_a.append(press.altitude_cal()) acc_cnt = 0 alt_cnt = 0 while (acc_cnt < 5): if (statistics.median(drop_synthetic_acc) >= DROP_ACCELERATION): acc_cnt = acc_cnt + 1 else: pass while (alt_cnt < 5): if (statistics.median(altitude_a) - statistics.median(altitude_b) < 0): alt_cnt = alt_cnt + 1 else: pass if (acc_cnt == 4 or alt_cnt == 4): t1 = time.time() break time.sleep(1 / SAMPLING_RATE)
def main(): tip_algoritm = '1' tip_nivel = 1 adancime = 2 Joc.JMAX = "0" Joc.JMIN = "x" N = 9 # linii M = 10 # coloane (tip_algoritm, tip_nivel, adancime, N, M) = get_input() # initializare tabla Joc.NR_LINII = int(N) Joc.NR_COLOANE = int(M) tabla_curenta = Joc() nr_mut_calc = 0 nr_mut_util = 0 print("Tabla initiala") print(str(tabla_curenta)) lista_timpi = [] # creare stare initiala stare_curenta = Stare(tabla_curenta, 'x', adancime) # setari interf grafica time1_tot = int(round(time.time() * 1000)) pygame.init() pygame.display.set_caption("Gabriel Cirstea x si 0") # dimensiunea ferestrei in pixeli ecran = pygame.display.set_mode(size=(M * 81 - 1, N * 81 - 1)) # Nrc*100+Nrc-1, Nrl*100+Nrl-1 # de_mutat = False patratele = deseneaza_grid(ecran, tabla_curenta.matr, N, M) selected_piece = None while True: if (stare_curenta.j_curent == Joc.JMIN): # muta jucatorul # preiau timpul in milisecunde de dinainte de mutare t_inainte = int(round(time.time() * 1000)) for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() if event.type == pygame.MOUSEBUTTONDOWN: pos = pygame.mouse.get_pos() # coordonatele clickului for np in range(len(patratele)): if patratele[np].collidepoint(pos): linie = np // M coloana = np % M ############################### if stare_curenta.tabla_joc.matr[np] == Joc.JMIN: selected_piece = np patratele = deseneaza_grid(ecran, stare_curenta.tabla_joc.matr,\ N, M, np) if stare_curenta.tabla_joc.matr[np] == Joc.GOL: if linie * M + coloana == stare_curenta.tabla_joc.Removed: continue if selected_piece: stare_curenta.tabla_joc.salt_piesa( selected_piece, np, Joc.JMAX) stare_curenta.tabla_joc.matr[np] = Joc.JMIN nr_mut_util += 1 # afisarea starii jocului in urma mutarii utilizatorului print("\nTabla dupa mutarea jucatorului") print(str(stare_curenta)) # preiau timpul in milisecunde de dupa mutare t_dupa = int(round(time.time() * 1000)) print("Utilizatorul a \"gandit\" timp de " + str(t_dupa - t_inainte) + " milisecunde.") patratele = deseneaza_grid( ecran, stare_curenta.tabla_joc.matr, N, M) # S-a realizat o mutare. Schimb jucatorul cu cel opus stare_curenta.j_curent = stare_curenta.jucator_opus( ) # -------------------------------- else: # jucatorul e JMAX (calculatorul) # Mutare calculator t_inainte = int(round(time.time() * 1000)) if tip_algoritm == '1': stare_actualizata = min_max(stare_curenta) else: # tip_algoritm==2 stare_actualizata = alpha_beta(-500, 500, stare_curenta) stare_curenta.tabla_joc = stare_actualizata.stare_aleasa.tabla_joc nr_mut_calc += 1 print("Tabla dupa mutarea calculatorului") print(str(stare_curenta)) patratele = deseneaza_grid(ecran, stare_curenta.tabla_joc.matr, N, M) # preiau timpul in milisecunde de dupa mutare t_dupa = int(round(time.time() * 1000)) print("Calculatorul a \"gandit\" timp de " + str(t_dupa - t_inainte) + " milisecunde.") lista_timpi.append(t_dupa - t_inainte) # S-a realizat o mutare. Schimb jucatorul cu cel opus stare_curenta.j_curent = stare_curenta.jucator_opus() # testez daca jocul a ajuns intr-o stare finala # si afisez un mesaj corespunzator in caz ca da if (afis_daca_final(stare_curenta)): break print("Timpul minim al calculatorului este ", min(lista_timpi), " milisecunde.") print("Timpul maxim al calculatorului este ", max(lista_timpi), " milisecunde.") print("Media calculatorului este ", statistics.mean(lista_timpi), " milisecunde.") print("Mediana calculatorului este ", statistics.median(lista_timpi), " milisecunde.") print("Numar mutari utilizator: ", nr_mut_util) print("Numar mutari calculator: ", nr_mut_calc) time2_tot = int(round(time.time() * 1000)) print("Jocul a durat in total " + str(time2_tot - time1_tot) + " milisecunde.")
if 'SameSite' in lines: same_site_num += 1 if 'Strict' in lines: strict_num += 1 if 'None' in lines: none_in_lines_num += 1 if 'path' in lines: total_path += 1 if 'path=/' in lines: path_to_none_num += 1 cookielist.append(cookie_num) cookielistfinal.append(cookielist[m] - cookielist[m - 1]) maximum = max(cookielistfinal) minimum = min( cookielistfinal) ## down here is how I got the max, min , and Median cookie_med = median(cookielistfinal) m += 1 print( str(cookie_num) + ' total number of cookies' + '\n' + 'mean of cookies ' + str(cookie_num / m)) print(str(secure_num) + ' number of secure cookies') print(str(http_only_num) + ' number of HTTP only') print(str(same_site_num) + ' number of SameSite') print(str(lax_num) + ' number of lax cookies') print(str(strict_num) + ' number of strict samesite') print(str(none_in_lines_num) + ' number of none samesite') print(str(total_path) + ' number of paths') print( str(path_to_none_num - total_path) + ' total number of paths that had var other than "/"') print(
import statistics # Print each value name for how they will appear below in order (for the user) print("Mean,", "Median,", "Mode,", "Min,", "Max") # First number line nums1 = [33, 5, 453, 21, 67, 657, 3425, 65, 21, 33, 44, 634, 543, 2345, 697] # Call the mean, median and mode using the statistics module from the first number line mean = statistics.mean(nums1) median = statistics.median(nums1) mode = statistics.mode(nums1) # Print results for line 1 print(mean, ",", median, ",", mode, ",", min(nums1), ",", max(nums1)) # Second number line nums2 = [65, 53, 485, 65, 453, 7895, 24, 65, 531, 24, 755, 342, 32, 1, 65, 99] # Call the mean, median and mode using the statistics module from the second number line mean = statistics.mean(nums2) median = statistics.median(nums2) mode = statistics.mode(nums2) # Print results for line 2 print(mean, ",", median, ",", mode, ",", min(nums2), ",", max(nums2)) # Third number line nums3 = [5435, 234, 398, 398, 534, 234, 65, 78, 66, 534, 456, 234, 54, 534, 56, 34, 77] # Call the mean, median and mode using the statistics module from the third number line mean = statistics.mean(nums3) median = statistics.median(nums3) mode = statistics.mode(nums3) # Print results for line 3 print(mean, ",", median, ",", mode, ",", min(nums3), ",", max(nums3))
def set_features_snp(dictionary): '''setta i valori delle features in base alle info estratte dai vcf''' for variante in dictionary.keys(): features=Features() varc_array=dictionary.get(variante) vett_BQ=[] vett_DP=[] vett_MQ0=[] index=0 for varcall in varc_array: if varcall is not "": vett_BQ=vett_BQ+[varcall.QB] vett_DP=vett_DP+[varcall.DP] if index == 0: features.GT_Freebayes=varc_array[0].GT features.QB_Freebayes=float(varc_array[0].QB) features.AF_Freebayes=float(varc_array[0].AF) features.CallFreebayes=varc_array[0].Call features.STRBIAS_Freebayes=varc_array[0].StrandBias elif index == 1: features.GT_Vardict=varc_array[1].GT features.QB_Vardict=float(varc_array[1].QB) features.MQ_Vardict=varc_array[1].MQ features.AF_Vardict=float(varc_array[1].AF) features.CallVardict=varc_array[1].Call features.STRBIAS_Vardict=varc_array[1].StrandBias elif index == 2: features.GT_Platypus=varc_array[2].GT features.AF_Platypus=float(varc_array[2].AF) features.CallPlatypus=varc_array[2].Call features.STRBIAS_Platypus=varc_array[2].StrandBias elif index == 3: features.GT_Gatk=varc_array[3].GT features.AF_Gatk=float(varc_array[3].AF) features.CallGatk=varc_array[3].Call features.MQ0_Gatk=float(varc_array[3].MQ0) features.MQ0F_Gatk=float(varc_array[3].MQ0F) features.MQRankSum_Gatk=varc_array[3].MQRankSum features.BQRankSum_Gatk=varc_array[3].BQRankSum features.StrBiasFS_Gatk=varc_array[3].StrBiasFS index = index + 1 vett_MQ0=[features.MQ0_Gatk] vett_MQ0F=[features.MQ0F_Gatk] vett_AF_media=[features.AF_Freebayes,features.AF_Vardict,features.AF_Platypus,features.AF_Gatk] vett_STRB_media=[features.STRBIAS_Freebayes,features.STRBIAS_Vardict,features.STRBIAS_Platypus,features.StrBiasFS_Gatk] AF_med=0 MQ0_med=0 MQ0F_med=0 SB_media=0 nDP=0 nMBQ=0 i=0 v=[] for dp in vett_DP: if dp and dp is not '': nDP= float(nDP)+float(dp) v=v+[float(dp)] i=i+1 try: features.DP=float(nDP)/float(i) features.DP_median= statistics.median(v) except: features.DP='.' try: features.DP_norm_median= float(features.DP_median)/float(opts.expectedMeanDP) except: features.DP_norm_median='.' i=0 v=[] for bq in vett_BQ: if bq is not '.': nMBQ= float(nMBQ)+float(bq) v=v+[float(bq)] i=i+1 try: features.BQ_media=float(nMBQ)/float(i) features.BQ_median= statistics.median(v) except: features.BQ_media='.' i=0 v=[] for strb in vett_STRB_media: if strb is not '.': SB_media=float(SB_media) + float(strb) v=v+[float(strb)] i=i+1 try: features.STRBIAS_media= float(SB_media)/float(i) features.STRBIAS_median= statistics.median(v) except: features.STRBIAS_media='.' i=0 v=[] for af in vett_AF_media: if af is not '.' and af is not '0': AF_med=float(AF_med) + float(af) v=v+[float(af)] i=i+1 try: features.AF_media= float(AF_med)/float(i) features.AF_median= statistics.median(v) except: features.AF_media='.' i=0 v=[] for mq in vett_MQ0: if mq is not '.': MQ0_med=float(MQ0_med) + float(mq) v=v+[float(mq)] i=i+1 try: features.MQ0_media= float(MQ0_med)/float(i) features.MQ0_median= statistics.median(v) except: features.MQ0_media='.' try: features.MQ0_norm_median= features.MQ0_median/float(opts.expectedMeanDP) except: features.MQ0_norm_median='.' i=0 v=[] for mqf in vett_MQ0F: if mqf is not '.': MQ0F_med=float(MQ0F_med) + float(mqf) v=v+[float(mqf)] i=i+1 try: features.MQ0F_media= float(MQ0_med)/float(i) features.MQ0F_median= statistics.median(v) except: features.MQ0F_media='.' dictionary[variante]= varc_array + [features]
def makeModel(self, halfData, checks=None): model = QtGui.QStandardItemModel(len(halfData), 7) model.setHorizontalHeaderLabels([ 'Depth', 'Elongation', 'Pressure', 'Temperature', 'Density', 'Fluid type', '' ]) densities = [0] types = [''] for row in range(len(halfData)): for col in range(7): if col in range(4): item = QtGui.QStandardItem(str(halfData[row][col])) elif col == 4: if row != 0: ro = round( (halfData[row][2] - halfData[row - 1][2]) / (halfData[row][0] - halfData[row][1] - halfData[row - 1][0] + halfData[row - 1][1]) * 10, 3) densities.append(ro) item = QtGui.QStandardItem(str(ro)) elif col == 5: if row != 0: if ro < 0.7: item = QtGui.QStandardItem("Gas") elif 0.7 < ro < 0.98: item = QtGui.QStandardItem("Oil") else: item = QtGui.QStandardItem("Water") types.append(item.text()) elif col == 6: if row != 0: item = QtGui.QStandardItem() item.setCheckable(True) item.setTextAlignment(QtCore.Qt.AlignCenter) model.setItem(row, col, item) numDots = round(len(halfData) / 3) + 1 calcList = densities[-numDots:] typesList = types[-numDots:] refType = None if typesList[-1] == typesList[-2] and 0.7 < calcList[ -1] < 1.25 and 0.7 < calcList[-2] < 1.25: refType = typesList[-1] elif typesList[-1] != typesList[-2] and 0.7 < calcList[ -1] < 1.25 and 0.7 < calcList[-2] < 1.25: if typesList[-2] == typesList[-3] and 0.7 < calcList[ -2] < 1.25 and 0.7 < calcList[-3] < 1.25: refType = typesList[-2] elif typesList[-2] != typesList[-3] and 0.7 < calcList[ -2] < 1.25 and 0.7 < calcList[-3] < 1.25: if typesList[-3] == typesList[-4] and 0.7 < calcList[ -3] < 1.25 and 0.7 < calcList[-4] < 1.25: refType = typesList[-3] else: maxNum = 0 typesSet = set(typesList) for fluidType in typesSet: num = typesList.count(fluidType) if num > maxNum or (num == maxNum and refType == "Gas"): maxNum = num refType = fluidType else: maxNum = 0 typesSet = set(typesList) for fluidType in typesSet: num = typesList.count(fluidType) if num > maxNum or (num == maxNum and refType == "Gas"): maxNum = num refType = fluidType if refType == "Water": target = 1.16 calcList = [ro for ro in calcList if ro >= 0.98] elif refType == "Oil": target = 0.88 calcList = [ro for ro in calcList if 0.7 < ro < 0.98] else: target = 0.5 calcList = [ro for ro in calcList if 0.01 <= ro < 0.7] if len(calcList) % 2 == 0: medianRo2 = median(calcList) indicator = False for i in range(len(calcList) - 1): if calcList[i] < medianRo2 < calcList[i + 1]: medianRo1 = calcList[i] medianRo3 = calcList[i + 1] indicator = True if i == len(calcList) - 2 and indicator == False: medianRo1 = medianRo2 medianRo3 = medianRo2 cond1 = (max(target, medianRo1) - min(target, medianRo1)) / max( target, medianRo1) cond2 = (max(target, medianRo2) - min(target, medianRo2)) / max( target, medianRo2) cond3 = (max(target, medianRo3) - min(target, medianRo3)) / max( target, medianRo3) if cond1 == min(cond1, cond2, cond3): medianRo = medianRo1 elif cond2 == min(cond1, cond2, cond3): medianRo = medianRo2 else: medianRo = medianRo3 else: medianRo = median(calcList) finalRo = [] altFinalRo = [] for row in range(len(halfData) - numDots, len(halfData)): m1 = max(float(model.index(row, 4).data()), medianRo) m2 = min(float(model.index(row, 4).data()), medianRo) if model.index(row, 5).data( ) == refType and (m1 - m2) / m1 < 0.08 and checks is None: model.item(row, 6).setCheckState(2) finalRo.append(float(model.item(row, 4).text())) else: altFinalRo.append(float(model.item(row, 4).text())) if checks is not None: for row in range(len(checks)): if checks[row]: model.item(row, 6).setCheckState(2) try: meanRo = mean(finalRo) except: meanRo = mean(altFinalRo) if 0.8 > meanRo or 1.2 < meanRo or 0.8 > meanRo or 1.2 < meanRo: self.warning = True mtmeterAbsDepth = float(model.item( len(halfData) - 1, 0).text()) - float( model.item(len(halfData) - 1, 1).text()) vdpAbsDepth = self.vdp - self.vdpElong delta = vdpAbsDepth - mtmeterAbsDepth ppl = round( float(model.item(len(halfData) - 1, 2).text()) + delta * meanRo / 10, 3) # lengthToReturn = len(finalRo) # if lengthToReturn == 0: lengthToReturn = len(altFinalRo) return model, round(meanRo, 3), ppl, refType, len(finalRo)
print('List:', length) #min & max print('Minimum:', length[0]) print('Maximum:', length[-1]) #mean summ = 0 for s in length: summ += s Mean = summ / len(length) print('Total length:', summ) print('Mean:', Mean) #median print('Median:', statistics.median(length)) #N50 summ2 = 0 for value in length: summ2 += value if summ2 > summ / 2: print('N50:', value) break
log2nd=np.log2(nd_) log2nd_=[x for x,y in zip(log2nd,type_l)if y=='BQC'] ax0.scatter(seq0BQC,log2nd_,s=2,color='r',label='BQC') log2nd_=[x for x,y in zip(log2nd,type_l)if y=='TQC'] ax0.scatter(seq0TQC,log2nd_,s=2,color='b',label='TQC') log2nd_=[x for x,y in zip(log2nd,type_l)if y=='SAMPLE'] ax0.scatter(seq0sam,log2nd_,s=2,color='k',alpha=.2) ax0.legend() q1,q3=np.quantile([x for x in log2nd if np.isfinite(x)],[.1,.9]) ub=q3+max(1,q3-q1) lb=q1-max(1,q3-q1) ax0.set_ylim(lb-.5,ub+.5) nd=[math.log2(x) for x,y in zip(nd_,type_l) if x>0 and y!='TQC'] if corr0: allmed=(statistics.median(nd)if nd else 0) else: allmed=0 adj_dat0=[] for adj0,cp0,cp1 in zip(adj0_l,[0]+change_pt,change_pt+[len(batch_l)]): seq1=seq0[cp0:cp1] adj0_=[x for x,y in zip(adj0,type_l[cp0:cp1]) if np.isfinite(x) and y!='TQC'] if corr0: adjmed=(statistics.median(adj0_) if adj0_ else 0) else: adjmed=0 nd1=[(x-adjmed+allmed if y!='TQC' else tqcy) for y,x,tqcy in zip(type_l[cp0:cp1],adj0,np.log2(nd_[cp0:cp1]))]
def __init__(self, parent, controller): tk.Frame.__init__(self, parent) label = tk.Label(self, text="Visalizer", font=LARGE_FONT) label.pack(pady=10, padx=10) button1 = ttk.Button(self, text="Go back to Homepage", command=lambda: controller.show_frame(StartPage)) button1.pack() fig = Figure(figsize=(5, 4), dpi=100) fig_2d = Figure(figsize=(6, 1), dpi=50) canvas = FigureCanvasTkAgg(fig, self) canvas.draw() canvas.get_tk_widget().pack(side=tk.RIGHT, fill=tk.BOTH, expand=False) # toolbar = NavigationToolbar2Tk(canvas, self) # toolbar.update() # canvas._tkcanvas.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True) canvas_2d = FigureCanvasTkAgg(fig_2d, self) canvas_2d.draw() canvas_2d.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=True) toolbar = NavigationToolbar2Tk(canvas_2d, self) toolbar.update() canvas_2d._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True) median = statistics.median(retro_master) standard_deviation = statistics.stdev(retro_master) median_label = tk.Label(self, text="Median of full Sign:{}".format(median), font=LARGE_FONT) median_label.pack(pady=10, padx=10) if median > 0.7: classification_status = 'Good Sign No change neeed' if median < 0.69: classification_status = 'Poor Sign as per retro Standards, Please consided changing the sign' sd_label = tk.Label( self, text="Standard Deviation of full:{}".format(standard_deviation), font=LARGE_FONT) sd_label.pack(pady=10, padx=10) classification_label = tk.Label( self, text="Classification Status {}".format(classification_status), font=LARGE_FONT) classification_label.pack(pady=10, padx=10) ax1 = fig.add_subplot(111, projection='3d') print(type(ax1)) ax2 = fig_2d.add_subplot(111) print(type(ax2)) if len(x3_great_point) > 0: #color the point green ax1.bar3d(x3_great_point, y3_great_point, z3_great_point, dx, dy, dz_great_point, color='g') else: pass if len(x3_average_point) > 0: #color the point y ax1.bar3d(x3_average_point, y3_average_point, z3_average_point, dx, dy, dz_average_point, color='y') else: pass if len(x3_above_average_point) > 0: #color the point orange ax1.bar3d(x3_above_average_point, y3_above_average_point, z3_above_average, dx, dy, dz_above_average_point, color='m') else: pass if len(x3_very_poor) > 0: #color the point orange ax1.bar3d(x3_very_poor, y3_very_poor, z3_very_poor, dx, dy, dz_very_poor, color='r') else: pass if (len(x3_great_point) > 0): button3 = ttk.Button(self, text="Only Good Points", command=lambda: [ ax1.clear(), ax1.bar3d(x3_great_point, y3_great_point, z3_great_point, dx, dy, dz_great_point, color='g') ]) button3.pack() if (len(x3_very_poor) > 0): button4 = ttk.Button(self, text="Only Poor Points", command=lambda: [ ax1.clear(), ax1.bar3d(x3_very_poor, y3_very_poor, z3_very_poor, dx, dy, dz_very_poor, color='r') ]) button4.pack() if (len(x3_above_average_point) > 0): button5 = ttk.Button(self, text="Only Above averge points", command=lambda: [ ax1.clear(), ax1.bar3d(x3_above_average_point, y3_above_average_point, z3_above_average, dx, dy, dz_above_average_point, color='m') ]) button5.pack() if (len(x3_average_point) > 0): button6 = ttk.Button(self, text="Only average point", command=lambda: [ ax1.clear(), ax1.bar3d(x3_average_point, y3_average_point, z3_average_point, dx, dy, dz_average_point, color='b') ]) button6.pack() if (len(retro_master) > 0): print(len(retro_master)) button7 = ttk.Button( self, text="Histograms", command=lambda: [ ax2.hist(dz_very_poor, bins, histtype='bar', color='r'), ax2.hist(dz_great_point, bins, histtype='bar', color='g'), ax2.hist(dz_average_point, bins, histtype='bar', color='y' ), ax2.hist(dz_above_average_point, bins, histtype='bar', color='m') ]) button7.pack() a = 0 bin_value_to_show_points = tk.Entry(self) bin_value_to_show_points.pack() button_to_plot_entered_value = ttk.Button( self, text="Plot points below entered value", command=lambda: [ updated_graph_points(df1.loc[ (df1['Retro'] <= float(bin_value_to_show_points.get()))]) ]) button_to_plot_entered_value.pack() ax1.set_xlabel('x') ax1.set_ylabel('y') ax1.set_zlabel('retro') ax1.set_zlim3d(0, 1)
n = int(input()) l = list(map(int, input.split()))[:n] from statistics import median q1 = median(l) ql1 = l[:q1] q2 = median(ql1) ql2 = l[q1:] q3 = median(ql2) print(q1) print(q2) print(q3)
def getPeriodicity(self, time=20, startTime=0, minSpeed=10, skip=12, smooth=2, minTime=9, forGraph=False): """returns periodicity, which is computed as a median time between two consecutive moments when a rat was mobile - times where its speed was higher than minSpeed ... additionally only periods more than minTime seconds are counted in a result ... this parameter is probably useful only in cases where a rat is moving and learned the task properly // minTime may be a list of values """ time = time * 60000 start = self.findStart(startTime) result = [] if type(minTime) != list: minTime = [minTime] moves = [] for minT in minTime: t0 = startTime * 60000 x0, y0 = self.data[start][7:9] minT *= 1000 speeds = deque() prev = False periods = [] for content in self.data[start + skip::skip]: if content[1] > time: break x1, y1 = content[7:9] t1 = content[1] speeds.append((sqrt( ((x1 - x0)**2 + (y1 - y0)**2)) / self.trackerResolution) / ((t1 - t0) / 1000)) if len(speeds) == smooth: if sum(speeds) / len(speeds) > minSpeed: if t0 - prev > minT and prev: periods.append(t0 - prev) if forGraph: moves.append((prev, t0)) prev = t1 speeds.popleft() x0, y0, t0 = x1, y1, t1 if len(periods) > 1: periodicity = format((median(periods) / 1000), "0.2f") else: periodicity = "NA" result.append(periodicity) if forGraph: return moves return "|".join(map(str, result))
a1 = int(input('insira: ')) a2 = int(input('insira: ')) a3 = int(input('insira: ')) a4 = int(input('insira: ')) a5 = int(input('insira: ')) a6 = int(input('insira: ')) a7 = int(input('insira: ')) a8 = int(input('insira: ')) a9 = int(input('insira: ')) a10 = int(input('insira: ')) a11 = int(input('1-Média, 2-mediana, 3-variância ou 4-desvio padrão. Qual sua escolha? ')) if(a11==1): print(st.mean([a1,a2,a3,a4,a5,a6,a7,a8,a9,10])) elif(a11==2): print(st.median([a1,a2,a3,a4,a5,a6,a7,a8,a9,10])) elif(a11==3): print(st.variance([a1,a2,a3,a4,a5,a6,a7,a8,a9,10])) elif(a11==4): print(st.stdev([a1,a2,a3,a4,a5,a6,a7,a8,a9,10])) #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# ATIVIDADE DIA- 20/04/21 #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# a = list () for a1 in range(0,10): a.append (float(input('digite: '))) print(f'os números selecionados foram {a}') print('os números selecionados foram {}'.format(a)) b = int(input('escolha uma opção: 1-Média, 2-mediana, 3-variância ou 4-desvio. Qual sua escolha? '))
#/usr/bin/python3 # #Class print("=" * 100) print("10.6 Mathematics") print("=" * 100) #math import math print(math.pi) print(math.pow(math.cos(1), 2) + math.pow(math.sin(1), 2)) print(math.log(1024, 2)) #random import random print(random.choice([1, 2, 3, 4, 5])) print(random.random()) print(random.randrange(10)) #statistics import statistics data = [1, 5, 2.65, 55.2, 46.2, 12] print(statistics.mean(data)) print(statistics.median(data)) print(statistics.variance(data))
import statistics import math file = open('timedif', 'r') strdeltas = file.readlines() deltas = list() total = 0 medianvalue = 0 meanvalue = 0 stderrvalue = 0 stddevvalue = 0 for delta in strdeltas: deltas.append(int(delta.rstrip())) total = sum(deltas) items = len(deltas) meanvalue = statistics.mean(deltas) medianvalue = statistics.median(deltas) stddevvalue = statistics.stdev(deltas) stderrvalue = stddevvalue / math.sqrt(items) print("SUM OF ALL DELTAS: ", total) print("NUMBER OF DELTAS: ", items) print("MEAN: ", meanvalue) print("MEDIAN: ", medianvalue) print("STD ERR: ", stderrvalue) print("STD DEV: ", stddevvalue)
y = y.astype(int) for a in range(0, 434): for b in range(0, 16): if ('y' in X[a][b]): X[a][b] = 1 elif ('n' in X[a][b]): X[a][b] = 0 medians = [] for x in range(0, 16): acceptable = [] for z in range(0, 434): if ((X[z][x] == 1) or (X[z][x] == 0)): acceptable.append(X[z][x]) med = median(acceptable) medians.append(int(med)) for c in range(0, 434): for d in range(0, 16): if ((X[c][d] != 1) and (X[c][d] != 0)): X[c][d] = medians[d] X = X.astype(int) from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) from sklearn.svm import SVC classifier = SVC(kernel='linear') classifier.fit(X_train, y_train)
import math print(math.cos(math.pi / 4)) print(math.log(1024, 2)) # Módulo random import random print(random.choice(['manzana', 'pera', 'banana'])) print(random.sample(range(100), 10)) # elección sin reemplazo print(random.random()) # un float al azar print(random.randrange(6)) # un entero al azar tomado de range(6) # Módulo statistics import statistics datos = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5] print(statistics.mean(datos)) print(statistics.median(datos)) print(statistics.variance(datos)) # Acceso a Internet """ from urllib.request import urlopen with urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl') as response: for line in response: line = line.decode('utf-8') # Decoding the binary data to text. if 'EST' in line or 'EDT' in line: # look for Eastern timer print(line) import smtplib server = smtplib.SMTP('localhost') server.sendmail('*****@*****.**', '*****@*****.**', "\"\"To: [email protected]
f.write(bytes(white_precision.to_string(), "utf-8")) y_pred = np.rint(y_pred).astype(int) f.write(b"\n") rang = range(min(min(y_pred), min(y_test)), max(max(y_pred), max(y_test)) + 1) CM = pd.DataFrame(confusion_matrix(y_test, y_pred), index=rang, columns=rang) f.write(bytes(CM.to_string(), "utf-8")) f.write(b"\n") f.write(b"================================\n") f.write(b"Median sampling\n") f.write(b"================================\n") counter = str(Counter(y_train)) f.write(bytes(counter, "utf-8")) f.write(b"\n") median = int(statistics.median(Counter(y_train).values())) sm = SMOTE(sampling_strategy={ min(y_test): median, max(y_test): median }, random_state=24, k_neighbors=2) Augmented_X_white, Augmented_Y_white = sm.fit_resample(X_train, y_train) counter = str(Counter(Augmented_Y_white)) f.write(bytes(counter, "utf-8")) f.write(b"\n") clf.fit(Augmented_X_white, Augmented_Y_white) y_pred = clf.predict(X_test) white_precision = pd.DataFrame(index=white_class, columns=["T=0.5 (%)", "T=1.0 (%)"])
def execute(self): self.log.debug("Executing bot: %s" % self.name) tolerance = self.config["external_price_tolerance"] spread = self.config["spread_percent"] min_balance = self.config["min_balance"] min_order_size = self.config["min_order_size"] quote = self.quote_symbol base = self.base_symbol ## Only load external prices if requires by the bot! ## and update only every maxAgePriceSec seconds maxAgePriceSec = self.config["maxAgePriceSec"] if (datetime.utcnow() - exchanges.lastupdate).total_seconds() > maxAgePriceSec: log.info("updating price from exchanges") exchanges.getAllPrices() # FIXME add weights true_price_per_btsx = statistics.median( self.exchanges.price_inbtsx[self.quote_symbol]) median = self.client.get_median(self.quote_symbol) new_price_per_btsx = true_price_per_btsx if median > new_price_per_btsx: new_price_per_btsx = median * MEDIAN_EDGE_MULTIPLE ## Cancel open orders if necessary canceled = [] quote_freed = 0 # freed funds from closing open orders base_freed = 0 result = self.client.get_asks_out_of_range( self.name, quote, base, new_price_per_btsx * (1 + spread), tolerance) canceled.extend(result[0]) base_freed += result[1] result = self.client.get_bids_less_than(self.name, quote, base, median) canceled.extend(result[0]) quote_freed += result[1] result = self.client.get_bids_out_of_range(self.name, quote, base, new_price_per_btsx, tolerance) canceled.extend(result[0]) quote_freed += result[1] asset_balance = self.client.get_balance(self.name, quote) + quote_freed btsx_balance = self.client.get_balance(self.name, base) + base_freed available_btsx_balance = btsx_balance - min_balance available_asset_buy_quantity = (asset_balance / new_price_per_btsx) - min_balance if len(canceled) > 0: self.log.info("Canceling orders: ") self.log.info("- freeing up %.5f %s" % (quote_freed, quote)) self.log.info("- freeing up %.5f %s" % (base_freed, base)) new_orders = [] if available_asset_buy_quantity > min_order_size: self.log.info("Submitting a bid...") new_orders.append([ "bid_order", [ self.name, available_asset_buy_quantity, base, new_price_per_btsx, self.quote_symbol ] ]) else: self.log.info("Skipping bid - %s balance of %.5f is too low" % (self.quote_symbol, available_asset_buy_quantity)) if available_btsx_balance > min_order_size: self.log.info("submitting an ask...") new_orders.append([ "ask_order", [ self.name, available_btsx_balance, base, new_price_per_btsx * (1 + spread), self.quote_symbol ] ]) else: self.log.info("Skipping ask - %s balance of %.5f is too low" % (self.base_symbol, available_btsx_balance)) for o in new_orders: self.log.info("new order %s: %s" % (o[0], o[1])) if len(canceled) > 0 or len(new_orders) > 0: self.log.info("Committing orders.") trx = self.client.request("wallet_market_batch_update", [canceled, new_orders, True]).json()
import statistics as stat n = int(input()) arr1 = [] arr2 = [] for i in range(n): list1, list2 = list(map(int, input().split())) arr1.append(list1) arr2.append(list2) mid1 = stat.median(arr1) mid2 = stat.median(arr2) sum1 = 0 sum2 = 0 for i in range(n): sum1 = sum1 + abs(arr1[i] - mid1) sum2 = sum2 + abs(arr2[i] - mid2) ans = int(min(sum1, sum2)) print(ans)