def test_numarray_cvx_conversions(): _1_10_ = numarray.array( range(1,11) ) test_cases = [ _1_10_, numarray.array([ _1_10_ ]), numarray.transpose( numarray.array([ _1_10_ ]) ), numarray.array([ _1_10_, range(11, 21) ]) ] for t, a in enumerate(test_cases): print "-"*80, '\nTest Case %d\n'%(t+1), "-"*80 print "NumArray matrix shaped", a.shape print a a_cvx = numarray_to_cvx(a) print "CVX matrix shaped", a_cvx.size print a_cvx a = numarray_asmatrix(a) a_numarray = cvx_to_numarray(a_cvx) m, n = a.shape assert (m,n)==a_cvx.size, \ "(m,n) = (%d,%d) != %s = a_cvx.size"%(m, n, a_cvx.size) assert (m,n)==a_numarray.shape, \ "(m,n) = (%d,%d) != %s = a_numarray.size"%(m, n, a_numarray.shape) for i in range(m): for j in range(n): assert a[i,j] == a_cvx[i,j], "a[%d,%d] = %f != %f = a_cvx[%d,%d]"%( i, j, a[i,j], a_cvx[i,j], i, j ) assert a[i,j] == a_numarray[i,j], "a[%d,%d] = %f != %f = a_numarray[%d,%d]"%( i, j, a[i,j], a_numarray[i,j], i, j ) print
def extract_res_assignment_plot_data(): xlocations = {'bws':None, 'procs':None, 'stors':None} xlocations['bws'] = na.array(range(num_links))+self.plot_head_margin xlocations['procs'] = self.plot_head_margin + num_links + \ na.array( range(0, 2*num_itrs, 2)) xlocations['stors'] = self.plot_head_margin + num_links + \ na.array( range(1, 2*num_itrs+1, 2)) # data = {'link_bws_actual':[0]*num_links, 'link_bws_cap':[0]*num_links, 'itr_procs_actual':[0]*num_itrs, 'itr_procs_cap':[0]*num_itrs, 'itr_stors_actual':[0]*num_itrs, 'itr_stors_model':[0]*num_itrs, 'itr_stors_cap':[0]*num_itrs} id_info_map = self.actual_res_dict['id_info_map'] for res_id in range(0,rid_len): if res_id < num_links: #res is link data['link_bws_actual'][res_id] = res_info_dict[res_id]['bw'] data['link_bws_cap'][res_id] = float(id_info_map[res_id]['bw_cap']) else: #res is itr id_ = res_id-num_links data['itr_procs_actual'][id_] = res_info_dict[res_id]['proc'] data['itr_procs_cap'][id_] = float(id_info_map[res_id]['proc_cap']) # data['itr_stors_actual'][id_] = res_info_dict[res_id]['stor_actual'] data['itr_stors_model'][id_] = res_info_dict[res_id]['stor_model'] data['itr_stors_cap'][id_] = float(id_info_map[res_id]['stor_cap']) return [data, xlocations]
def levin_campello(b, N, constraint, snr_db, ctf, gamma, txpow): ctf = numarray.array(ctf) b = numarray.array(b) # gain to noise ratio snr = 10 ** (snr_db / 10) avtxpow = txpow / N # average tx power norm_ctf_sqrd = abs(ctf) ** 2 / (sum(abs(ctf) ** 2) / N) g = snr / avtxpow * norm_ctf_sqrd # prepare beta = 1 gn = prepare_table(g, gamma, beta) min_ie = lambda b: min_c(gn, b / beta) max_ie = lambda b: max_c(gn, b / beta) energy = lambda b, n: gamma / g[n] * (2.0 ** b[n] - 1) # energy efficiency b = EF(b, beta, min_ie, max_ie) # e-tightness S = sum(map(lambda x: energy(b, x), range(N))) b = ET(b, beta, constraint, S, min_ie, max_ie) # set changes e = map(lambda x: energy(b, x), range(N)) print "sum(e)", sum(e) b = list(b) return (b, e)
def rate_adaptive_policy(self, ctf, cur_tx_power, cur_tx_constraint, snr_db, cur_ber): ber = max(self.required_ber, 1e-7) # a=0.0004 # b=0.00001 # # # ber_err = ber-cur_ber # self.ber_state = max(1e-12,self.ber_state + (a+b)*ber_err - b*self.last_ber_err) # self.last_ber_err = ber_err # # ber = min(.5,max(1e-12,self.ber_state)) # # print "current ber",cur_ber # print "ber_err",ber_err # print "ber state",self.ber_state gamma = (2.0 / 3.0) * (erfcinv(ber) ** 2.0) * 3.2 # gamma = ((2./3.)*(erfcinv(ber))**2.0) print "input ber", ber, "required ber", self.required_ber print "snr gap (dB) for req. ber", 10 * log10(gamma) N = self.subcarriers (b, e) = levin_campello(self.mod_map, N, cur_tx_constraint, snr_db, ctf, gamma, cur_tx_power) b = numarray.array(b) e = numarray.array(e) a = numarray.array(zeros(len(self.assignment_map))) if sum(b < 0) > 0: print "WARNING: bit loading < 0" b[b < 0] = 0 a[b > 0] = 1 txpow = sum(e) e = e / txpow * N print "txpow", txpow print "tx amplitude", sqrt(txpow) # print numarray.array(map(lambda x: "%.2f" % (x), e)) # print numarray.array(map(lambda x: "%d" % (x),b)) # return self.tx_amplitude = sqrt(txpow) self.mod_map = list(b) self.pa_vector = list(e) self.assignment_map = list(a) frame_length_samples = 12 * self.block_length # FIXME constant bits_per_frame = sum(b) * 9 # FIXME constant frame_duration = frame_length_samples / self.bandwidth self.data_rate = bits_per_frame / frame_duration print "Datarate", self.data_rate
def __init__(self, simulationParameterObj, actionParameterObj, Bad_Action_Penalty, nbrReaches=REACHES, habitatSize=HABITATS, fixedStartState=False, discountFactor=0.9, seed=None): """ :param simulationParameterObj (SimulationParameterClass), contains all the parameters for the domain :param actionParameterObj (ActionParameterClass), contains all the parameters for the actions :param Bad_Action_Penalty (float), a negative value which will be returned as the consequence of over-budget action or non-allowable action on a state :param nbrReaches (int), number of reaches in the river network :param habitatSize (int), number of habitat in each reach :param fixedStartState (bool), indicates using a random starting state or fixed starting state :param discountFactor (float), discount factor :param seed (int), seed for random number generator (default=None) """ self.seed = seed self.fixedStartState = fixedStartState self.discountFactor = discountFactor self.Bad_Action_Penalty=Bad_Action_Penalty if not self.seed is None: self.randGenerator = random.Random(self.seed) else: self.randGenerator = random.Random() if simulationParameterObj != None: self.simulationParameterObj = simulationParameterObj self.actionParameterObj = actionParameterObj self.dispertionTable = [] self.germinationObj = None else: #upstream rate upStreamRate = 0.1 #downstream rate downStreamRate = 0.5 #exogenous arrival indicator exogenousArrivalIndicator = SimulationParameterClass.ExogenousArrivalOn #competiton parameter competitionFactor = 1 #there is the same number of reachArrivalRates = array([[random.randint(100, 1000) for i in xrange(2)] for i in xrange(nbrReaches)]) reachArrivalProbs = array([[random.random() for i in xrange(2)] for i in xrange(nbrReaches)]) #first value is for native and the second one for tamarisk prodRate = [200, 200] #first value is for native and the second one for tamarisk deathRate = [0.2, 0.2] graph = InvasiveUtility.createRandomGraph(nbrReaches + 1, balanced=True,randGenerator=self.randGenerator) self.simulationParameterObj = SimulationParameterClass(nbrReaches, habitatSize, prodRate, deathRate, exogenousArrivalIndicator, reachArrivalRates, reachArrivalProbs, upStreamRate, downStreamRate, competitionFactor, graph) self.actionParameterObj = ActionParameterClass(costPerTree=0.1, eradicationCost=0.5, restorationCost=0.9, eradicationRate=1, restorationRate=1, costPerReach=10, emptyCost=0.05, varEradicationCost=0.4, varInvasiveRestorationCost=0.8, varEmptyRestorationCost=0.4, budget=100)
def levin_campello(b,N,constraint,snr_db,ctf,gamma,txpow,ber=0,coding=0): # 1e-2 SNR_diff = [3.0, 3.2, 4.0, 3.5, 3.0, 3.0, 3.2, 3.4] #1e-4 #SNR_diff = [1.5, 3.5, 4.3, 4.0, 4.1, 4.4, 4.6, 4.8] SNR_diff = numarray.array(SNR_diff) SNR_diff_lin = 10**(SNR_diff/10) ctf = numarray.array(ctf) b = numarray.array(b) # gain to noise ratio snr = 10**(snr_db/10) avtxpow = txpow/N # average tx power norm_ctf_sqrd = abs(ctf)**2 / (sum(abs(ctf)**2)/N) g = snr/avtxpow * norm_ctf_sqrd # prepare beta = 1 if coding==1: nbits = numpy.array([0.,1.,2.,2.,4.,4.,6.,6.,6.,8.]); infobits = numpy.array([0.,0.5,1.,1.5,2.,3.,4.,4.5,5.,6.]); codingrate = numpy.array([1.,0.5,0.5,0.75,0.5,0.75,0.5,2./3.,0.75,0.75]); gn = prepare_table(g,gamma,beta,SNR_diff_lin,coding,infobits,codingrate) min_ie = lambda b : min_c(gn,b/beta) max_ie = lambda b : max_c(gn,b/beta) energy = lambda m,n : gamma[m[n]] / g[n] / codingrate[m[n]] * (2**infobits[m[n]]-1) else: gn = prepare_table(g,gamma,beta,SNR_diff_lin) min_ie = lambda b : min_c(gn,b/beta) max_ie = lambda b : max_c(gn,b/beta) energy = lambda b,n : gamma[b[n]]/g[n]*(2.0**b[n]-1) # energy efficiency b = EF(b,beta,min_ie,max_ie) # e-tightness S = sum(map(lambda x : energy(b,x),range(N))) b = ET(b,beta,constraint,S,min_ie,max_ie) # set changes e = map(lambda x :energy(b,x),range(N)) print "sum(e)",sum(e) b = list(b) return (b,e)
def OP(func, n): y = [] for i in xrange(1, n+1): y.append(func(i)) x = [] for i in xrange(1, n+1): row = [] for j in xrange(1, n+1): row.append(i**(n-j)) x.append(row) constants = solve(array(x), array(y)) return lambda x: calculatePolynom(list(constants), x)
def barchart(): # pickled = open('pickleName', 'rU') # # barData = pickle.load(pickled) # # data = barData[0] # labels = barData[1] labels = ["hg19", "ACAT", "AGTT", "ATCT", "CAGT", "GACT", "TCAT"] data = [2001, 989, 8853, 12040, 1028, 1101, 9672] # total number of reads that align to tRNA / million reads that map to repeats # Sample Total Reads Aligned reads #Jia475.s_1_sequence.ACAT.fastq compute-00-02 15511090 1531721 #Jia475.s_1_sequence.AGTT.fastq compute-00-03 8893756 3782255 #Jia475.s_1_sequence.ATCT.fastq compute-00-04 7646993 3492888 #Jia475.s_1_sequence.CAGT.fastq compute-00-05 6929395 777614 #Jia475.s_1_sequence.GACT.fastq compute-00-06 28490744 782489 #Jia475.s_1_sequence.TCAT.fastq compute-00-07 19030312 6902208 xlocations = na.array(range(len(data)))+0.5 width = 0.6 bar(xlocations, data, width=width) # yticks(range(0, 5000)) xticks(xlocations+ width/2, labels) xlim(0, xlocations[-1]+width*2) title("Reads that align to tRNA (pseudo)genes (per million reads mapped to repeats)") gca().get_xaxis().tick_bottom() gca().get_yaxis().tick_left() show() savefig('tRNA_reads.png')
def visualize_types(): """ This will plot the graph according to the types of crime """ parsed_data = parse.parse(parse.MY_FILE, ",") #Get the parsed data #Counter would give us the tally of each dayofweek counter = Counter(item["Category"] for item in parsed_data) labels = tuple(counter.keys()) #Here we are directly using counter.keys() coz the order of list doesn't matter xlocations = na.array(range(len(labels))) + 0.5 #these are the locations of xticks # [0.5, 1.5, 2.5, ... , 16.5, 17.5] width = 0.5 plt.bar(xlocations, counter.values(), width=width) plt.xticks(xlocations + width / 2, labels, rotation=90) #plot the x ticks between the bars. that's why width/2 #labels should be vertical plt.subplots_adjust(bottom=0.4) #To move the graph up because of long labels. See days.png and days1.png plt.savefig("/home/isthegeek/Web/Days1.png") plt.clf()
def visualize_type(parsed_data): """Visualize data by category in a bar graph""" # Make a new variable, 'counter', from iterating through # each line of data in the parsed data, and count how # many incidents happen by category counter = Counter(item["Category"] for item in parsed_data) # Set the labels which are based on the keys of our counter. # Since order doesn't matter, we can just use counter.keys() # Needs to be a tuple for plt.xticks() labels = tuple(counter.keys()) # Set exactly where the labels hit the x-axis xlocations = na.array(range(len(labels))) + 0.5 # Width of each bar that will be plotted width = 0.5 # Assign data to a bar plot (similar to plt.plot()!) plt.bar(xlocations, counter.values(), width=width) # Assign labels and tick location to x-axis plt.xticks(xlocations + width / 2, labels, rotation=90) # Give some more room so the x-axis labels aren't cut off # in the graph plt.subplots_adjust(bottom=0.4) # Make the overall graph/figure larger plt.rcParams['figure.figsize'] = 12, 8 # Render the graph! plt.show()
def funcEnergyBarPlot(plotSaveInfo, totalBarAxesList): timeLabels = ["%s" %time.strftime("%a %b %d", time.strptime(t, "%Y%m%d%H%M%S")) for t, e in totalBarAxesList] noPresenceEnergy = [e[0] for t, e in totalBarAxesList] presenceEnergy = [e[1] for t, e in totalBarAxesList] noPresenceMeanPower = [e[2] for t, e in totalBarAxesList] width = 0.5 xIndex = na.array(range(len(timeLabels))) + width fig = plt.figure(2) # another figure other than line power plot ax1 = fig.add_subplot(111) ax1.set_xlabel("Time") p11 = ax1.bar(xIndex, presenceEnergy, width, color='r', alpha=0.5) p12 = ax1.bar(xIndex, noPresenceEnergy, width, color='y', bottom=presenceEnergy, alpha=0.5) ax1.set_ylabel('kWh') ax1.set_title("%s's Energy Profile" %plotSaveInfo[1][0]) #ax1.set_xticks(xIndex+width/2., timeLabels) ax1.set_xlim(0, xIndex[-1]+width*2) ax1.legend((p11[0], p12[0]), ('Occupied', 'Unoccupied')) ax2 = ax1.twinx() ax2.plot(xIndex+width/2., noPresenceMeanPower, "bo-") ax2.set_ylabel("No presence mean power (W)") plt.xticks(xIndex+width/2., timeLabels) pngSavePath = "%s/%s_bar.png" %(plotSaveInfo[0], plotSaveInfo[1][0]) plt.savefig(pngSavePath) return pngSavePath
def harmonic_mean(self, v): '''Computes the harmonic mean of vector v''' x = numarray.array(v) #debug(DEBUG, "Bwe vect: %s", str(x)) m = 1.0/(sum(1.0/x)/len(x)) #debug(DEBUG, "Harmonic mean: %.2f", m) return m
def draw_parplots(chrName): """this is draw barplot for each chromosome """ path = "/nfs/th_group/hk3/MAPPABLE_DATA_HG19/MAPPABLE_COMPARISIONS" ful_file_name = path + "/" + chrName + ".results" try: f = open(ful_file_name, "r") except IOError as e: print "Cannot open the file. Possibly data for this chromosome not exist yet!" lines = f.readlines() f.close() required_line = lines[1] inter, UnotR, RnotU, uni = required_line.split() labels = ["Intersection", "UW_not_RG", "RG_not_UW", "Union"] colors = ["r", "g", "y", "b"] data = [float(inter), float(UnotR), float(RnotU), float(uni)] xlocations = na.array(range(len(data))) + 0.1 width = 0.5 bar(xlocations, data, width=width, color=colors) yticks(range(0, 120, 10)) xticks(xlocations + width / 2, labels) xlim(0, xlocations[-1] + width * 2) Title = chrName + ": intersection, differences and union of mappality data: John Stam and RG Lab" title(Title) gca().get_xaxis().tick_bottom() gca().get_yaxis().tick_left() ylabel("Percentage") show()
def visualize_type(): """Visualize data by category in a bar graph""" data_file = parse(MY_FILE, ",") counter = Counter(item["Category"] for item in data_file) labels = tuple(counter.keys()) # set where the labels hit the x-axis xlocations = na.array(range(len(labels))) + 0.5 # width of each bar width = 0.5 # assign data to a bar plot plt.bar(xlocations, counter.values(), width=width) # assign labels and tick location to x-axis plt.xticks(xlocations + width / 2, labels, rotation=90) # adjust room so labels aren't cut off at the bottom plt.subplots_adjust(bottom=0.4) plt.rcParams['figure.figsize'] = 20, 12 plt.savefig("Type11.png") plt.clf()
def readAMat(amatname): """Read a PLearn .amat file and return it as a numarray Array. Return a tuple, with as the first argument the array itself, and as the second argument the fieldnames (list of strings). """ ### NOTE: this version is much faster than first creating the array and ### updating each row as it is read... Bizarrely enough f = open(amatname) a = [] fieldnames = [] for line in f: if line.startswith("#size:"): (length,width) = line[6:].strip().split() elif line.startswith("#sizes:"): # ignore input/target/weight/extra sizes continue elif line.startswith("#:"): fieldnames = line[2:].strip().split() pass elif not line.startswith('#'): # Add all non-comment lines. row = [ safefloat(x) for x in line.strip().split() ] if row: a.append(row) f.close() return array(a), fieldnames
def visualize_type(): """Visualize data by category in a bar graph""" data_file = parse(MY_FILE, ",") # Same as before, this returns a dict where it sums the total # incidents per Category. counter = Counter(item["Category"] for item in data_file) # Set the labels which are based on the keys of our counter. labels = tuple(counter.keys()) # Set where the labels hit the x-axis xlocations = na.array(range(len(labels))) + 0.5 # Width of each bar width = 0.5 # Assign data to a bar plot plt.bar(xlocations, counter.values(), width=width) # Assign labels and tick location to x-axis plt.xticks(xlocations + width / 2, labels, rotation=90) # Give some more room so the labels aren't cut off in the graph plt.subplots_adjust(bottom=0.4) # Make the overall graph/figure larger plt.rcParams['figure.figsize'] = 12, 8 # Save the graph! # If you look at new-coder/dataviz/tutorial_source, you should see # the PNG file, "Type.png". This is our graph! plt.savefig("Type.png") # Close figure plt.clf()
def visualize_type(): """Visualize data by category in a bar graph""" data_file = parse(MY_FILE, ',') # num of incidents per category counter = Counter(item['Category'] for item in data_file) # Set the labels labels = tuple(counter.keys()) # Set exactly where the labels hit the x-axis xlocations = na.array(range(len(labels))) + 0.5 # Width of each bar width = 0.5 # Assign data to a bar plot plt.bar(xlocations, counter.values(), width=width) # Assign labels and tick location to x-axis plt.xticks(xlocations + width / 2, labels, rotation=90) # Give some more room so the x-axis labels aren't cut off plt.subplots_adjust(bottom=0.4) # Make the overall graph/figure larger plt.rcParams['figure.figsize'] = 12, 8 # save plt.savefig('Type.png') # close plt.clf()
def visualize_overlaps(resutlsFile, chrName): """this is to visualize overlaps in terms of intesection(A,B), diff(A,B),diff(B,A), union(A,B) """ try: f = open(resutlsFile) except IOError as e: print "Cannot open the file." sys.exit() lines = f.readlines() f.close() required_line = lines[0] inter, AnotB, BnotA, uni = required_line.split() inter = round(float(inter) / float(uni) * 100, 2) AnotB = round(float(AnotB) / float(uni) * 100, 2) BnotA = round(float(BnotA) / float(uni) * 100, 2) uni = round(float(uni) / float(uni) * 100, 2) labels = ["Intersection", "UW_not_RG", "RG_not_UW", "Union"] colors = ["r", "g", "y", "b"] data = [inter, AnotB, BnotA, uni] xlocations = na.array(range(len(data))) + 0.1 width = 0.5 bar(xlocations, data, width=width, color=colors) yticks(range(0, 120, 10)) xticks(xlocations + width / 2, labels) xlim(0, xlocations[-1] + width * 2) Title = chrName + ": Intersection, differences and union" title(Title) gca().get_xaxis().tick_bottom() gca().get_yaxis().tick_left() ylabel("Percentage") show()
def plot_speculative_session_alloc(self, r, ax, g_info_dict, s_info_dict): width, length =0.1, 0.1 #for bars sid_len = len(s_info_dict) max_numspaths = g_info_dict['max_numspaths'] color_map = { 'bw':'#9999ff', 'proc':'#ff9999', 'dur':'green' } # def extract_pr_plot_data(r): #r must be in xlocs, ylocs, pr_data = [], [], [] for s_id in range(0,sid_len): s_pr = s_info_dict[s_id]['p_'+r] for p_id in range(0, max_numspaths): x = p_id+1-width/2 y = s_id+1-length/2 z = float('{0:.2f}'.format(s_pr[p_id])) xlocs.append(x) ylocs.append(y) pr_data.append(z) #displaying z values with text on top of bars ax.text(x=x+width/2, y=y+length/2, z=z*1.1, s=str(z), color='b', \ ha='center', va= 'bottom', fontsize=9) # return [xlocs, ylocs, pr_data] # [xlocs, ylocs, pr_data] = extract_pr_plot_data(r) ax.bar3d(xlocs, ylocs, z=[0]*len(ylocs), dx=width, dy=length, dz=pr_data, \ color=color_map[r], alpha=0.4) #setting tick labels xtick_locs = na.array(range(max_numspaths))+1 xtick_strs = ['P'+`i` for i in range(max_numspaths)]
def plot_res__session_portion_alloc(self, r, ax, res_info_dict, sid_len, ll_index): width, length =0.1, 0.1 #for bars rid_len = len(res_info_dict) color_map = { 'bw':'#9999ff', 'proc':'#ff9999', 'dur':'green' } #y: s_id, x:r_id def extract_rr_plot_data(r): #r must be in xlocs, ylocs, rs_data = [], [], [] head, tail = None, None if r == 'bw': head, tail = 0, ll_index+1 else: #r = 'proc' or 'dur' head, tail = ll_index+1, rid_len # for r_id in range(head,tail): rs_cap = res_info_dict[r_id][r+'_palloc_list'] for s_id in range(0, sid_len): y = s_id+1-width/2 x = r_id+1-length/2-(head) z = float('{0:.2f}'.format(rs_cap[s_id])) xlocs.append(x) ylocs.append(y) rs_data.append(z) #displaying z values with text on top of bars ax.text(x=x+width/2, y=y+length/2, z=z*1.1, s=str(z), color='b', \ ha='center', va= 'bottom', fontsize=9) # return [head, tail, xlocs, ylocs, rs_data] # [head, tail, xlocs, ylocs, rs_data] = extract_rr_plot_data(r) ax.bar3d(xlocs, ylocs, z=[0]*len(ylocs), dx=width, dy=length, dz=rs_data, \ color=color_map[r], alpha=0.4) #setting tick labels ytick_locs = na.array(range(sid_len))+1 ytick_strs = ['S'+`i` for i in range(sid_len)]
def visualize_type(data_file): """Visualize data by category in a bar graph""" # Same as before, this returns a dict where it sums the total # incidents per Category. counter = Counter(item["Category"] for item in data_file) # Set the labels which are based on the keys of our counter. labels = tuple(counter.keys()) # Set where the labels hit the x-axis xlocations = na.array(range(len(labels))) + 0.5 # Width of each bar width = 0.5 # Assign data to a bar plot plt.bar(xlocations, counter.values(), width=width) # Assign labels and tick location to x- and y-axis plt.xticks(xlocations + width / 2, labels, rotation=90) plt.yticks(range(0, max(counter.values()), 5)) # Give some more room so the labels aren't cut off in the graph plt.subplots_adjust(bottom=0.4) # Make the overall graph/figure larger plt.rcParams['figure.figsize'] = 12, 8 # Render the graph! plt.show()
def PIC2(): location = na.array(range(185)) b1 = bar(location, num_ave1, width=0.6, color='c') xticks(range(140, 190, 5)) yticks(range(0, 50000, 1000)) xlim(135, 190) ylim(0, 10000) show()
def PIC(NUM): location = na.array(range(185)) b1 = bar(location, NUM, width=1, color='c') xticks(range(140, 190, 5)) yticks(range(0, 1300, 100)) xlim(135, 190) ylim(0, 1200) show()
def levin_campello_margin(b,N,constraint,snr_db,ctf,gamma,txpow,required_ber): if (required_ber > 1.01e-3): #experimental # 1e-2 SNR_diff = [3.0, 3.2, 4.0, 3.5, 3.0, 3.0, 3.2, 3.4] else: #1e-4 SNR_diff = [1.5, 3.5, 4.3, 4.0, 4.1, 4.4, 4.6, 4.8] SNR_diff = numarray.array(SNR_diff) SNR_diff_lin = 10**(SNR_diff/10) ctf = numarray.array(ctf) b = numarray.array(b) # gain to noise ratio snr = 10**(snr_db/10) avtxpow = txpow/N # average tx power norm_ctf_sqrd = abs(ctf)**2 / (sum(abs(ctf)**2)/N) g = snr/avtxpow * norm_ctf_sqrd # prepare beta = 1 gn = prepare_table(g,gamma,beta,SNR_diff_lin) min_ie = lambda b : min_c(gn,b/beta) max_ie = lambda b : max_c(gn,b/beta) energy = lambda b,n : gamma/g[n]*(2.0**b[n]-1)*SNR_diff_lin[b[n]-1] # energy efficiency b = EF(b,beta,min_ie,max_ie) # e-tightness #S = sum(map(lambda x : energy(b,x),range(N))) # print "sum_b", sum(b) #b_sum=sum(map(lambda x : b(x),range(N))) b_sum=sum(b) b = BT(b,beta,constraint,b_sum,min_ie,max_ie) # set changes e = map(lambda x :energy(b,x),range(N)) print "sum(e)",sum(e) b = list(b) return (b,e)
def test_torque_precision(self,auto=False): if not auto and not self.is_dpm3_ready(): return res={} amp=self.test_default[self.jid]['test_torques']['medium'] print '------------------' print 'Hysterisis test:',k,':',amp log_torque_mNm_a, log_load_mNm_a=self.slew_to_torque(amp,3.0,zero=False,loadcell=True) log_torque_mNm_b, log_load_mNm_b=self.slew_to_torque(-1*amp,3.0,zero=False,loadcell=True) p=na.array(log_torque_mNm_a,na.Float32).mean() n=na.array(log_torque_mNm_b,na.Float32).mean() pl=na.array(log_load_mNm_a,na.Float32).mean() nl=na.array(log_load_mNm_b,na.Float32).mean() res[k]={'sea':{'avg_pos':p,'avg_neg':n,'hystersis':abs(p-n), 'zero':(p+n)/2.0}, 'loadcell':{'avg_pos':pl,'avg_neg':nl,'hystersis':abs(pl-nl), 'zero':(pl+nl)/2.0}} print 'Hystersis SEA',res[k]['sea']['hystersis'],'mNm' print 'Hystersis Loadcell',res[k]['loadcell']['hystersis'],'mNm' self.write_test_results({'test_torque_tracking':res})
def scanSequence(mix, bg, seq,scoring='mix'): """ Scores all positions of a sequence with the given model and background. @param mix: MixtureModel object @param bg: background MixtureModel object @param seq: sequence as list of nucleotides @param scoring: flag to determine the scoring scheme used for the mixtures. 'compmax' means maximum density over the components, 'mix' means true mixture density @return: list of position-wise log-odd scores """ # convert sequence to internal representation, alphabet of seq must be DNA alph = mixture.Alphabet(['A','C','G','T']) f = lambda x: alph.internal(x) seq=map(f,seq) dnr = mix.components[0].dist_nr # init with dummy value at first position s = numarray.array([[-1]+ seq[0:dnr-1]]) score = [] for i in range(dnr-1,len(seq),1): # shift query sequence by one position s[0] = numarray.concatenate( [s[0][1:],numarray.array([seq[i]])],0) if scoring == 'compmax': # score as maximum over components c_m_l = numarray.zeros(mix.G,numarray.Float) for i in range(mix.G): c_m_l[i] = mix.components[i].pdf(s)[0] m_l = c_m_l.max() elif scoring == 'mix': m_l = mix.pdf(s)[0] bg_l = bg.pdf(s)[0] score.append(m_l-bg_l) return score
def plotNonDiagHitDist(mummerOpFileName, minMatchLen, intervalLen): #get the file name for plot plotFileName = os.path.basename(mummerOpFileName).split('.')[0] #get the file dir plotFileDir = os.path.dirname(mummerOpFileName) #initialize py plot for non interactive backend matplotlib.use('Agg') #indicate to pyplot that we have new figure #needed to comment following to run on strong bad #figure() hits = getHits(mummerOpFileName, minMatchLen) #construct bins based on hit length strength #list contain each bin min value, max value given by next 1 less than #next in the list binLabels = range(0, HitDistConsts.MAX_BIN_MINLEN, intervalLen) binCount = [0 for i in binLabels] currBinInd = 0 for hitLen in hits: #find appropriate bin index while (hitLen > binLabels[currBinInd+1]): currBinInd += 1 binCount[currBinInd] += 1 #start trimming bins from end till not empty for i in range(len(binCount)-1, -1, -1): if binCount[i] != 0: break if i != len(binCount) -1: binCount = binCount[0:i+2] binLabels = binLabels[0:i+2] binShortLabels = [label/1000 for label in binLabels] #plot bar graph of hitcount with hit labels xLocations = na.array(range(len(binLabels))) width = 0.5 bar(xLocations, binCount, width=width) #yticks(range(0, 8)) xticks(xLocations, binShortLabels) xlim(0, xLocations[-1]+width*2) title("hit count distribution") gca().get_xaxis().tick_bottom() gca().get_yaxis().tick_left() #needed 'ps' format to run on strongbad savefig(os.path.join(plotFileDir + plotFileName + '.ps'), format='ps')
def visualize_type(): parsed_data = parse.parse(MY_FILE, ",") counter = Counter(item["Category"] for item in parsed_data) category_tuple = tuple(counter.keys()) xlocations = na.array(range(len(category_tuple))) + 0.5 matplotlib.pyplot.bar(xlocations, counter.values()) matplotlib.pyplot.xticks(xlocations, category_tuple, rotation=90) matplotlib.pyplot.subplots_adjust(bottom=0.4) matplotlib.pyplot.rcParams["figure.figsize"]= 12,8 matplotlib.pyplot.show()
def PIC1(): location = na.array(range(185)) b1 = bar(location, num_height, width=0.6, color='c') xticks(range(140, 190, 5)) yticks(range(0, 50000, 1000)) xlim(135, 190) ylim(0, 10000) xlabel('Height', fontsize=12) ylabel('The number of each Height', fontsize=12) show()
def extract_sching_result_plot_data(): #Assuming s_info_dict and base_info_list are in-sync xlocations = {} for i in range(0, bil_len): xlocations[i] = na.array([x*bil_len+i for x in range(0, sid_len)])+self.plot_head_margin # data = {'bw':[], 'proc':[], 'dur':[], 'r_soft_perf':[], 'stor':[]} for s_id in s_info_dict: for base_info in base_info_list: data[base_info].append(s_info_dict[s_id][base_info]) return [data, xlocations]
def translatePDB(pdb, vector): newPDB = [] for res in pdb: newRes = res.copy() for atom in newRes.atomlist: #print atom #print newRes[atom] newRes[atom] = numarray.array(newRes[atom]) newRes[atom] = newRes[atom] + vector #print newRes[atom][0] #print '' newPDB.append(newRes) return newPDB
def visualize_type(): """Visualize data by category in a bar graph""" data_file = prs.parse(MY_FILE, ",") counter = Counter(item["Category"] for item in data_file) labels = tuple(counter.keys()) xlocations = na.array(range(len(day))) + 0.5 width = 0.5 plt.bar(xlocations, counter.values(), width=width) plt.xticks(xlocations + width / 2, labels, rotation=90) plt.subplots_adjust(bottom=0.4) plt.rcParams['figure.figsize'] = 12, 8 plt.savefig("Type.png") plt.clf()
def levin_campello_margin(b, N, constraint, snr_db, sinr_sc, gamma, txpow): sinr_sc = numarray.array(sinr_sc) #ctf = numarray.array(ctf) b = numarray.array(b) # gain to noise ratio snr = 10**(snr_db / 10) sinr_sc_lin = 10**(sinr_sc / 10.0) avtxpow = txpow / N # average tx power norm_sinr_sc = sinr_sc_lin / (sum(sinr_sc_lin) / N) g = snr / avtxpow * norm_sinr_sc # norm_ctf_sqrd = abs(ctf)**2 / (sum(abs(ctf)**2)/N) # g = snr/avtxpow * norm_ctf_sqrd # prepare beta = 1 gn = prepare_table(g, gamma, beta) min_ie = lambda b: min_c(gn, b / beta) max_ie = lambda b: max_c(gn, b / beta) energy = lambda b, n: gamma / g[n] * (2.0**b[n] - 1) # energy efficiency b = EF(b, beta, min_ie, max_ie) # e-tightness #S = sum(map(lambda x : energy(b,x),range(N))) print "sum_b", sum(b) #b_sum=sum(map(lambda x : b(x),range(N))) b_sum = sum(b) b = BT(b, beta, constraint, b_sum, min_ie, max_ie) # set changes e = map(lambda x: energy(b, x), range(N)) print "sum(e)", sum(e) b = list(b) return (b, e)
def test_torque_precision(self, auto=False): if not auto and not self.is_dpm3_ready(): return res = {} amp = self.test_default[self.jid]['test_torques']['medium'] print '------------------' print 'Hysterisis test:', k, ':', amp log_torque_mNm_a, log_load_mNm_a = self.slew_to_torque(amp, 3.0, zero=False, loadcell=True) log_torque_mNm_b, log_load_mNm_b = self.slew_to_torque(-1 * amp, 3.0, zero=False, loadcell=True) p = na.array(log_torque_mNm_a, na.Float32).mean() n = na.array(log_torque_mNm_b, na.Float32).mean() pl = na.array(log_load_mNm_a, na.Float32).mean() nl = na.array(log_load_mNm_b, na.Float32).mean() res[k] = { 'sea': { 'avg_pos': p, 'avg_neg': n, 'hystersis': abs(p - n), 'zero': (p + n) / 2.0 }, 'loadcell': { 'avg_pos': pl, 'avg_neg': nl, 'hystersis': abs(pl - nl), 'zero': (pl + nl) / 2.0 } } print 'Hystersis SEA', res[k]['sea']['hystersis'], 'mNm' print 'Hystersis Loadcell', res[k]['loadcell']['hystersis'], 'mNm' self.write_test_results({'test_torque_tracking': res})
def extract_plot_data(s_info_dict, base_info_list, width): global plot_head_margin #Assuming s_info_dict and base_info_list are in-sync sid_len = len(s_info_dict) bil_len = len(base_info_list) # xlocations = {} for i in range(0, bil_len): xlocations[i] = na.array([x*bil_len+i for x in range(0, sid_len)])+plot_head_margin # data = {'bw':[], 'proc':[], 'dur':[], 'n':[]} for s_id in s_info_dict: for base_info in base_info_list: data[base_info].append(s_info_dict[s_id][base_info]) return [data, xlocations]
def plotNBars(Xs, Ys, labels, xlabel, ylabel, title, plotter, ylog=False, horizontalLine=None, verticalLine=None): """Como myPlot, pero en vez de curvas, barras.""" import numpy.numarray as na maxData = max(map(len, Xs)) minVal = min(map(min, Xs)) xlocations = na.array(range(maxData)) width = 0.7 i = 0 colores = ['b', 'r', 'g', 'c', 'm', 'y', 'k', 'w', '#610b0b'] bar_width = float(width / len(Xs)) for (x, y, l) in zip(Xs, Ys, labels): plotter.bar(map(lambda t: t + bar_width * i, x), y, bar_width, label=l, color=colores[i], log=ylog) i += 1 plotter.ylabel(ylabel) plotter.xlabel(xlabel) plotter.title(title) if horizontalLine: hline = plotter.axhline(linewidth=2, color='r', y=horizontalLine, linestyle='dashed') bars.append(hline) if verticalLine: plotter.axvline(linewidth=2, color='r', x=verticalLine) plotter.legend() plotter.xticks(xlocations + width / 2 + minVal, xlocations + minVal, fontsize=12) #, rotation = 30 return plotter
def regular_xyval_to_2d_grid_values(xyval): """Returns (grid_values, x0, y0, deltax, deltay)""" xyval = numarray.array(xyval) n = len(xyval) x = xyval[:, 0] y = xyval[:, 1] values = xyval[:, 2:].copy() # print "type(values)",type(values) valsize = numarray.size(values, 1) x0 = x[0] y0 = y[0] k = 1 if x[1] == x0: deltay = y[1] - y[0] while x[k] == x0: k = k + 1 deltax = x[k] - x0 ny = k nx = n // ny # print 'A) nx,ny:',nx,ny values.shape = (nx, ny, valsize) # print "A type(values)",type(values) values = numarray.transpose(values, (1, 0, 2)) # print "B type(values)",type(values) elif y[1] == y0: deltax = x[1] - x[0] while y[k] == y0: k = k + 1 deltay = y[k] - y0 nx = k ny = n // nx # print 'B) nx,ny:',nx,ny values.shape = (ny, nx, valsize) # print "C type(values)",type(values) values = numarray.transpose(values, (1, 0, 2)) # print "D type(values)",type(values) else: raise ValueError( "Strange: x[1]!=x0 and y[1]!=y0 this doesn't look like a regular grid..." ) print 'In regular_xyval_to_2d_grid_values: ', type(xyval), type(values) return values, x0, y0, deltax, deltay
def extract_sching_result_plot_data(): #Assuming s_info_dict and base_info_list are in-sync xlocations = {} for i in range(0, bil_len): xlocations[i] = na.array( [x * bil_len + i for x in range(0, sid_len)]) + self.plot_head_margin # data = { 'bw': [], 'proc': [], 'dur': [], 'r_soft_perf': [], 'stor': [] } for s_id in s_info_dict: for base_info in base_info_list: data[base_info].append(s_info_dict[s_id][base_info]) return [data, xlocations]
def visualize_type(): """Visualize data by category in a bar graph""" # grab our parsed data parsed_data = parse.parse(DATA_FILE, ",") # make a new variable, 'counter', from iterating through each line # of data in the parsed data, and count how many incidents happen # by category counter = Counter(item["Category"] for item in parsed_data) # Set the labels which are based on the keys of our counter. # Since order doesn't matter, we can just used counter.keys() labels = tuple(counter.keys()) # Set exactly where the labels hit the x-axis xlocations = na.array(range(len(labels))) + 0.5 # Width of each bar that will be plotted width = 0.5 # Assign data to a bar plot (similar to plt.plot()!) plt.bar(xlocations, counter.values(), width=width) # Assign labels and tick location to x-axis plt.xticks(xlocations + width / 2, labels, rotation=90) #Increase bottom side to adjust labels plt.subplots_adjust(bottom=0.4) #Mkae the overall graph/figure large plt.rcParams['figure.figsize'] = 12, 8 #show the graph plt.show() #save the graph plt.savefig("Type.png") #close figure plt.clf()
def center_at_origin(pdb): newPDB = [] #center = array(calcCAcentroid(pdb)) LIZA center = numarray.array(calcCAcentroid(pdb)) print "$$$$$$$$$$$$$$$$$$$$$$$$calcCAcentroid", calcCAcentroid(pdb) print "$$$$$$$$$$$$$$$$$$$$$$$$center", center for res in pdb: newRes = res.copy() #print newRes.printid for atom in newRes.atomlist: #print atom #print newRes[atom] print "$$$$$$$$$$$$$newRes[atom in before after", newRes[atom] newRes[atom] = array(newRes[atom]) print "$$$$$$$$$$$$$newRes[atom in center after", newRes[atom] newRes[atom] = newRes[atom] - center #print newRes[atom][0] #print '' newPDB.append(newRes) return newPDB
def calls_by_csr(): call_file = p.parse(CALL_DATA, ",") begin_date = raw_input("Start date (Month dd, yyyy): ") end_date = raw_input("End date( Month dd, yyyy): ") ice_hours = raw_input("Ice Hours: ") joey_hours = raw_input("Joey Hours: ") branton_hours = raw_input("Branton Hours: ") bj_hours = raw_input("BJ Hours: ") chuck_hours = raw_input("Chuck Hours: ") averyhart_hours = raw_input("Averyhart Hours: ") jacob_hours = raw_input("Jacob Hours: ") counter = Counter( item["Agent"] for item in call_file if item["Date/Time"] >= begin_date and item["Date/Time"] <= end_date and item["Call Status"] == "Completed" and item["Minutes"] > "1") call_list = [(float(counter["Brent Gauthier"]) / float(bj_hours)), (float(counter["Joey Doughty"]) / float(joey_hours)), (float(counter["Matt Intemann"]) / float(ice_hours)), (float(counter["Branton Phillips"]) / float(branton_hours)), (float(counter["Matt Averyhart"]) / float(averyhart_hours)), (float(counter["Jacob Ellis"]) / float(jacob_hours)), (float(counter["Charles Marczynski"]) / float(chuck_hours))] csr_list = tuple( ["BJ", "Joey", "Iceman", "Branton", "Averyhart", "Jacob", "Chuck"]) xlocations = na.array(range(len(csr_list))) + 0.5 width = 0.5 rects1 = plt.bar(xlocations, call_list, width, color='green') plt.xticks(xlocations + width / 2, csr_list, rotation=90) plt.subplots_adjust(bottom=0.2) plt.rcParams['figure.figsize'] = 12, 12 plt.suptitle("Inbound & Outboud Calls Per Hour Worked From " + begin_date + " to " + end_date, fontsize=12) plt.ylabel("Inbound & Outboud Calls Per Hour Worked > 1 min", fontsize=12) autolabel(rects1) plt.savefig("phone_calls_per_hour_graph.png") plt.clf()
def plot_ale(self): a_scores = [] names = [] for pl in self['pipelines']: try: a_scores.append(pl['stats']['ale_score']) names.append(pl['name']) except: pass if len(a_scores) < 2: print ('Not enough ALE scores') return ## normalize scores old_min = min(a_scores) old_max = max(a_scores) new_min = 5 new_max = 100 old_range = old_max - old_min new_range = new_max - new_min n_scores = [] for a in a_scores: n = (((a - old_min) * new_range) / old_range) + new_min n_scores.append(n) xlocations = na.array(range(len(n_scores))) + 0.5 width = 0.5 fig = plt.figure() plt.bar(xlocations, n_scores, width=width, linewidth=0, color='#CC99FF') plt.xticks(xlocations + width/2, names) plt.xlim(0, xlocations[-1]+width*2) plt.title("Relative ALE Scores") plt.yticks(range(0, new_max + 10, 10)) ale_fig = os.path.join(self['datapath'], str(self['job_id']), 'ale.png') plt.savefig(ale_fig) return ale_fig
def plot_res__session_portion_alloc(self, r, ax, res_info_dict, sid_len, ll_index): width, length = 0.1, 0.1 #for bars rid_len = len(res_info_dict) color_map = {'bw': '#9999ff', 'proc': '#ff9999', 'dur': 'green'} #y: s_id, x:r_id def extract_rr_plot_data(r): #r must be in xlocs, ylocs, rs_data = [], [], [] head, tail = None, None if r == 'bw': head, tail = 0, ll_index + 1 else: #r = 'proc' or 'dur' head, tail = ll_index + 1, rid_len # for r_id in range(head, tail): rs_cap = res_info_dict[r_id][r + '_palloc_list'] for s_id in range(0, sid_len): y = s_id + 1 - width / 2 x = r_id + 1 - length / 2 - (head) z = float('{0:.2f}'.format(rs_cap[s_id])) xlocs.append(x) ylocs.append(y) rs_data.append(z) #displaying z values with text on top of bars ax.text(x=x+width/2, y=y+length/2, z=z*1.1, s=str(z), color='b', \ ha='center', va= 'bottom', fontsize=9) # return [head, tail, xlocs, ylocs, rs_data] # [head, tail, xlocs, ylocs, rs_data] = extract_rr_plot_data(r) ax.bar3d(xlocs, ylocs, z=[0]*len(ylocs), dx=width, dy=length, dz=rs_data, \ color=color_map[r], alpha=0.4) #setting tick labels ytick_locs = na.array(range(sid_len)) + 1 ytick_strs = ['S' + ` i ` for i in range(sid_len)]
def visualize_type(data_file): """Visualize data by category in a bar graph""" # Same as before, this returns a dict where it sums the total # incidents per Category. counter = Counter(item["Category"] for item in data_file) # Set the labels which are based on the keys of our counter. labels = tuple(counter.keys()) # Set where the labels hit the x-axis xlocations = na.array(range(len(labels))) + 0.5 # Width of each bar width = 0.5 # Assign data to a bar plot plt.bar(xlocations, counter.values(), width=width) # Assign labels and tick location to x- and y-axis plt.xticks(xlocations + width / 2, labels, rotation=90) plt.yticks(range(0, max(counter.values()), 5)) # Give some more room so the labels aren't cut off in the graph plt.subplots_adjust(bottom=0.4) # Make the overall graph/figure larger plt.rcParams['figure.figsize'] = 12, 8 # Save the graph! # If you look at new-coder/dataviz/tutorial_source, you should see # the PNG file, "Type.png". This is our graph! plt.savefig("Type.png") # Close figure plt.clf()