def num_8_divisors(max_n): total = 0 primes = primesfrom2to(max_n/6) a_max = max_n**(1./3) for idx_a,a in enumerate(primes): # abc, all unique if (a > a_max): break else: for idx_b,b in enumerate(primes[idx_a+1:]): c_max = max_n/(a*b) if (c_max<=a or c_max<=b): break else: nearest_prime_to_c_max_index = bisect(primes[idx_a+1:],c_max)-1 index_diff = nearest_prime_to_c_max_index-idx_b total += index_diff #for c in primes: #if (c<=b): #continue #else: #if (a*b*c > max_n): #break #else: #total += 1 b_max = (max_n/2.)**(1./3) for b in primes: # ab^3, a,b unique if (b > b_max): break else: a_max = max_n/b**3 if (a_max<=1): break else: nearest_prime_to_a_max_index = bisect(primes,a_max)-1 #print nearest_prime_to_a_max_index if (nearest_prime_to_a_max_index>=0): if (a_max>=b): total += (nearest_prime_to_a_max_index) elif (a_max<b): total += (nearest_prime_to_a_max_index+1) else: break #for a in primes: #if (a==b): #continue #elif (a > (max_n/8)): #break #else: #if (a*b**3 > max_n): #break #else: #total += 1 for a in primes: if (a**7 > max_n): break else: total += 1 return total
def compute_interval_chi2(ts_obj, file_obj, curr_dir, meas_file, chi2_range, data_label): logger = logging.getLogger(LOGGING_NAME) meas_obj = ts_obj.get_cached_file(curr_dir, meas_file) if meas_obj == None: logger.error('Can not compute interval chi^2 since measured radiance file does not exist for run: %s' % curr_dir) return None try: wl_conv = file_obj[WAVELENGTH_COLUMN][:,0] except LookupError: logger.error('Could not retrieve column: %s from file: %s' % (WAVELENGTH_COLUMN, file_obj.filename)) return None try: wl_meas = meas_obj[WAVELENGTH_COLUMN][:,0] except LookupError: logger.error('Could not retrieve column: %s from file: %s' % (WAVELENGTH_COLUMN, meas_obj.filename)) return None conv_beg = bisect.bisect(wl_conv, chi2_range[0]) conv_end = bisect.bisect(wl_conv, chi2_range[1]) meas_beg = bisect.bisect(wl_meas, chi2_range[0]) meas_end = bisect.bisect(wl_meas, chi2_range[1]) residual = meas_obj[RADIANCE_COLUMN][meas_beg:meas_end, 0] - file_obj[RADIANCE_COLUMN][conv_beg:conv_end, 0] interval_chi2 = numpy.sum( numpy.power(residual / meas_obj[ERROR_COLUMN][meas_beg:meas_end, 0], 2) ) return [ (data_label, interval_chi2) ]
def read_read(r, frags, frag_chunk): name, seq, _, _, ali = r.split('\t')[:5] crm, strand, pos = ali.split(':')[:3] positive = strand == '+' len_seq = len(seq) if positive: pos = int(pos) else: pos = int(pos) + len_seq - 1 # remove 1 because all inclusive frag_piece = frags[crm][pos / frag_chunk] idx = bisect(frag_piece, pos) try: next_re = frag_piece[idx] except IndexError: # case where part of the read is mapped outside chromosome count = 0 while idx >= len(frag_piece) and count < len_seq: pos -= 1 count += 1 frag_piece = frags[crm][pos / frag_chunk] idx = bisect(frag_piece, pos) if count >= len_seq: raise Exception('Read mapped mostly outside ' + 'chromosome\n') next_re = frag_piece[idx] prev_re = frag_piece[idx - 1 if idx else 0] return ('%s\t%s\t%d\t%d\t%d\t%d\t%d\n' % ( name, crm, pos, positive, len_seq, prev_re, next_re))
def get_middle(self, cid, val_l, val_r, l=True, r=True): if val_l > val_r: val_l, val_r = val_r, val_l l, r = r, l reverse = True else: reverse = False if l is True: i = bisect.bisect_left(self.sorted_values[cid], val_l) else: i = bisect.bisect(self.sorted_values[cid], val_l) if r is True: i2 = bisect.bisect(self.sorted_values[cid], val_r) else: i2 = bisect.bisect_left(self.sorted_values[cid], val_r) altids = self.sorted_altid[cid][i:i2] values = self.sorted_values[cid][i:i2] if reverse is True: altids.reverse() values.reverse() return altids, values
def get_slice(self, val, upper_val=None): """ Get sub-histogram by slicing the axis at this value. returns a tuple (histogram, (low, high)) where low and high are the bounds of the slice taken. """ warnings.warn('This method will be replaced by slice()', FutureWarning, stacklevel=2) bin_bounds = np.linspace(self.min,self.max,self.bins + 1) bin_n = bisect.bisect(bin_bounds, val) extent = self._get_bounds(bin_bounds, bin_n) if upper_val is not None: if not upper_val > val: raise ValueError('upper_val must be > val') # should add 1 to ensure that the upper bin is counted upper_bin = bisect.bisect(bin_bounds, upper_val) + 1 upper_extent = self._get_bounds(bin_bounds, upper_bin) extent = (extent[0], upper_extent[1]) else: upper_bin = None # _get_slice should take care of copying subhist = self._hist._get_slice(self.name, bin_n, upper_bin) return subhist, extent
def solve(n, i_min, free, curr_board, pieces_left, solutions, fps=fps, se_nh=se_nh, bisect=bisect): fp_i_cands = fps[i_min] for p in pieces_left: fp_cands = fp_i_cands[p] for fp in fp_cands: if fp <= free: n_curr_board = curr_board[:] for ci in fp: n_curr_board[ci] = p if len(pieces_left) > 1: n_free = free - fp n_i_min = min(n_free) if len(n_free & se_nh[n_i_min]) > 0: n_pieces_left = pieces_left[:] n_pieces_left.remove(p) solve(n, n_i_min, n_free, n_curr_board, n_pieces_left, solutions) else: s = "".join(map(str, n_curr_board)) solutions.insert(bisect(solutions, s), s) rs = s[::-1] solutions.insert(bisect(solutions, rs), rs) if len(solutions) >= n: return if len(solutions) >= n: return return
def _Truncate(dc, text, maxWidth, ellipse, ellipseChars): """ Return a string that will fit within the given width. """ line = text.split("\n")[0] # only consider the first line if not line: return "" pte = dc.GetPartialTextExtents(line) # Does the whole thing fit within our given width? stringWidth = pte[-1] if stringWidth <= maxWidth: return line # We (probably) have to ellipse the text so allow for ellipse maxWidthMinusEllipse = maxWidth - dc.GetTextExtent(ellipseChars)[0] if ellipse == wx.LEFT: i = bisect.bisect(pte, stringWidth - maxWidthMinusEllipse) return ellipseChars + line[i+1:] if ellipse == wx.CENTER: i = bisect.bisect(pte, maxWidthMinusEllipse / 2) j = bisect.bisect(pte, stringWidth - maxWidthMinusEllipse / 2) return line[:i] + ellipseChars + line[j+1:] if ellipse == wx.RIGHT: i = bisect.bisect(pte, maxWidthMinusEllipse) return line[:i] + ellipseChars # No ellipsing, just truncating is the default i = bisect.bisect(pte, maxWidth) return line[:i]
def _parseindex(self, seq, all): """Internal: parse a message number (or cur, first, etc.).""" if isnumeric(seq): try: return int(seq) except (OverflowError, ValueError): return sys.maxint if seq in ('cur', '.'): return self.getcurrent() elif seq == 'first': return all[0] elif seq == 'last': return all[-1] else: if seq == 'next': n = self.getcurrent() i = bisect(all, n) try: return all[i] except IndexError: raise Error, 'no next message' if seq == 'prev': n = self.getcurrent() i = bisect(all, n - 1) if i == 0: raise Error, 'no prev message' try: return all[i - 1] except IndexError: raise Error, 'no prev message' raise Error, None return
def add_field(self, field, private=False): # Insert the given field in the order in which it was created, using # the "creation_counter" attribute of the field. # Move many-to-many related fields from self.fields into # self.many_to_many. if private: self.private_fields.append(field) elif field.is_relation and field.many_to_many: self.local_many_to_many.insert(bisect(self.local_many_to_many, field), field) else: self.local_fields.insert(bisect(self.local_fields, field), field) self.setup_pk(field) # If the field being added is a relation to another known field, # expire the cache on this field and the forward cache on the field # being referenced, because there will be new relationships in the # cache. Otherwise, expire the cache of references *to* this field. # The mechanism for getting at the related model is slightly odd - # ideally, we'd just ask for field.related_model. However, related_model # is a cached property, and all the models haven't been loaded yet, so # we need to make sure we don't cache a string reference. if field.is_relation and hasattr(field.remote_field, 'model') and field.remote_field.model: try: field.remote_field.model._meta._expire_cache(forward=False) except AttributeError: pass self._expire_cache() else: self._expire_cache(reverse=False)
def plot_distributions(distributions, bucket_pct, axes, out_file): x_max, y_max = axes pp = PdfPages(out_file) variances = sorted(distributions) subsamples = sorted(distributions[variances[-1]]) if x_max == 0.: x_max = distributions[0][-1] bucket_width = x_max * bucket_pct bucket_boundaries = np.arange(0, x_max + bucket_width / 2., bucket_width) x_axis_points = np.arange(bucket_width / 2., x_max, bucket_width) for i,v in enumerate(variances): plt.figure(i) plt.xlabel("regret distribution") if v == 0: plt.title("true game") cum_dist = np.array([bisect(distributions[0], b) for b in \ bucket_boundaries]) plt.plot(x_axis_points, (cum_dist[1:] - cum_dist[:-1]) / \ float(cum_dist[-1]), label="true game") else: plt.title("$\sigma \\approx$" +str(v)) for s in subsamples: cum_dist = np.array([bisect(distributions[v][s], b) for b in \ bucket_boundaries]) plt.plot(x_axis_points, (cum_dist[1:] - cum_dist[:-1]) / \ float(cum_dist[-1]), label=str(s)+" samples") plt.legend(loc="upper right", prop={'size':6}) if y_max != 0.: plt.axis([0, x_max, 0, y_max]) pp.savefig() pp.close()
def add_field(self, field): # Insert the given field in the order in which it was created, using # the "creation_counter" attribute of the field. # Move many-to-many related fields from self.fields into # self.many_to_many. if field.rel and isinstance(field.rel, ManyToManyRel): self.local_many_to_many.insert(bisect(self.local_many_to_many, field), field) if hasattr(self, '_m2m_cache'): del self._m2m_cache else: self.local_fields.insert(bisect(self.local_fields, field), field) self.setup_pk(field) if hasattr(self, '_field_cache'): del self._field_cache del self._field_name_cache # The fields, concrete_fields and local_concrete_fields are # implemented as cached properties for performance reasons. # The attrs will not exists if the cached property isn't # accessed yet, hence the try-excepts. try: del self.fields except AttributeError: pass try: del self.concrete_fields except AttributeError: pass try: del self.local_concrete_fields except AttributeError: pass if hasattr(self, '_name_map'): del self._name_map
def p187(): N=10**8 total=0 for x in range(bisect(primes, sqrt(N))): p = primes[x] total += bisect(primes, N/p) - x return total
def getMotifAnno(annoIntvlDict,intervalStartDict,intervalEndDict,motifChrom,motifStart,motifEnd,window): """push excluded regions from BED6 into a list if motif falls into it""" regionList = [] valueList = [] #itl = IntervalList( intv for intv in geneRangeDict[motifChrom]) try: startList = [start for (start,end) in intervalStartDict[motifChrom]] endList = [end for (start,end) in intervalEndDict[motifChrom]] intervalStartList = [(start,end) for (start,end) in intervalStartDict[motifChrom]] intervalEndList = [(start,end) for (start,end) in intervalEndDict[motifChrom]] iStart = bisect(startList, motifEnd) iEnd = bisect(endList,motifStart) s = intervalStartList[:iStart] e = intervalEndList[iEnd:] overlapping = list(set(s)&set(e)) #intervals = intervalDict[motifChrom]##for short list of Bed6 Anno, brute force is Ok #motifInterval = Interval(motifStart, motifEnd) #overlapping = [ x for x in intervals \ # if ((x[1]+window)>motifInterval[0] and (x[0]-window)<motifInterval[0]) \ # or ((x[1]+window)>motifInterval[1] and (x[0]-window)<motifInterval[1]) ] #print 'overlapping',overlapping if not len(overlapping) == 0: for x in overlapping: (anno, value) = annoIntvlDict[motifChrom][x] if not anno in regionList: regionList.append(anno) if not (anno, value) in valueList: valueList.append((anno,value)) #if len(targetList) > 1: #print targetList, motifChrom, motifInterval except KeyError: pass return regionList, valueList
def colored(p, pallete=None, inverse=False): """ return a color code for the percentage. """ pallete = pallete or DEFUALT_PALLETE if inverse: return pallete['colors'][len(pallete['colors']) - bisect(pallete['limits'], p)] return pallete['colors'][bisect(pallete['limits'], p)]
def _delta_to_next(self, last_run_at, next_hour, next_minute): """ Takes a datetime of last run, next minute and hour, and returns a relativedelta for the next scheduled day and time. Only called when day_of_month and/or month_of_year cronspec is specified to further limit scheduled task execution. """ from bisect import bisect, bisect_left datedata = AttributeDict(year=last_run_at.year) days_of_month = sorted(self.day_of_month) months_of_year = sorted(self.month_of_year) def day_out_of_range(year, month, day): try: datetime(year=year, month=month, day=day) except ValueError: return True return False def roll_over(): while 1: flag = datedata.dom == len(days_of_month) or day_out_of_range( datedata.year, months_of_year[datedata.moy], days_of_month[datedata.dom] ) if flag: datedata.dom = 0 datedata.moy += 1 if datedata.moy == len(months_of_year): datedata.moy = 0 datedata.year += 1 else: break if last_run_at.month in self.month_of_year: datedata.dom = bisect(days_of_month, last_run_at.day) datedata.moy = bisect_left(months_of_year, last_run_at.month) else: datedata.dom = 0 datedata.moy = bisect(months_of_year, last_run_at.month) if datedata.moy == len(months_of_year): datedata.moy = 0 roll_over() while 1: th = datetime(year=datedata.year, month=months_of_year[datedata.moy], day=days_of_month[datedata.dom]) if th.isoweekday() % 7 in self.day_of_week: break datedata.dom += 1 roll_over() return ffwd( year=datedata.year, month=months_of_year[datedata.moy], day=days_of_month[datedata.dom], hour=next_hour, minute=next_minute, second=0, microsecond=0, )
def run(self, edit): # Filter out any cursors that are larger than a single point. cursor_pts = tuple(cursor.a for cursor in self.view.sel() if cursor.a == cursor.b) diff_starts = tuple(region.a for region in self.view.find_all("^diff")) hunk_starts = tuple(region.a for region in self.view.find_all("^@@")) for cursor_pt in cursor_pts: diff_start = diff_starts[bisect.bisect(diff_starts, cursor_pt) - 1] diff_start_line = self.view.substr(self.view.line(diff_start)) hunk_start = hunk_starts[bisect.bisect(hunk_starts, cursor_pt) - 1] hunk_line_str = self.view.substr(self.view.line(hunk_start)) hunk_line, _ = self.view.rowcol(hunk_start) cursor_line, _ = self.view.rowcol(cursor_pt) additional_lines = cursor_line - hunk_line - 1 # Example: "diff --git a/src/js/main.spec.js b/src/js/main.spec.js" --> "src/js/main.spec.js" use_prepix = re.search(r" b/(.+?)$", diff_start_line) if use_prepix is None: filename = diff_start_line.split(" ")[-1] else: filename = use_prepix.groups()[0] # Example: "@@ -9,6 +9,7 @@" --> 9 lineno = int(re.search(r"^@@ \-\d+(,-?\d+)? \+(\d+)", hunk_line_str).groups()[1]) lineno = lineno + additional_lines self.load_file_at_line(filename, lineno)
def search(self, seq): """ search for first occurrence of given sequence(s) in the UniProtDB objects collection returning (each) the fasta header front part of the first occurrence. :param seq: a string interpreted as a single sequence or a list (of str) interpreted as a coll. of sequences :return: a dictionary of sequences to lists (of ids, 'null' if n/a) """ if isinstance(seq, str): ids = 'null' index = self.searchstring.find(seq) if index >= 0: j = bisect.bisect(self.idx, index) - 1 ids = self.accs[j] return {seq: ids} if isinstance(seq, list): ids = list() for i in seq: ids.append('null') for i, v in enumerate(seq): index = self.searchstring.find(v) if index >= 0: j = bisect.bisect(self.idx, index) - 1 ids[i] = self.accs[j] return dict(zip(seq, ids)) return None
def wrs(ws,k,debug=False,return_rs=False): """Weighted reservoir sampling for k items""" _dbg = lambda x:_dbg(x,debug) js = [] rs = [] for j,w in enumerate(ws): r = random.random()**(1.0/w) #dbg( "considering j:%s, w:%s, r:%s" % (j,w,r)) if j < k: #dbg( "preinserting j:%s, w:%s, r:%s" % (j,w,r)) pos = bisect.bisect(rs,r) js.insert(pos,j) rs.insert(pos,r) else: #dbg( "comparing r: %s to rs:%s" % (r,rs)) pos = bisect.bisect(rs,r) #dbg( "pos: %s" % pos) if pos > 0: #dbg( "inserting") js.insert(pos,j) rs.insert(pos,r) js = js[-k:] rs = rs[-k:] if return_rs: return js,rs else: return js
def add(self, region): if len(self) == 0: self.append(region) return # merge the rest check_items = self tmp = [] start = bisect(self, sublime.Region(region.begin(), region.begin())) - 1 start = 0 if start < 0 else start end = bisect(self, sublime.Region(region.end(), region.end())) end = 0 if end < 0 else end if end == 0: self.insert(0, region) return elif start == len(self): self.append(region) return check_items = self[start:end] start_time = perf_counter() for item in check_items: if region.intersects(item): region = region.cover(item) else: tmp.append(item) self[start:end] = tmp # insert new region i = bisect_left(self, region) self.insert(i, region)
def getTargetGene(geneRangeDict, intervalStartDict, intervalEndDict, motifChrom, motifStart, motifEnd, txWindow): """push motif target genes into a list""" targetList = [] transcriptList = [] #itl = IntervalList( intv for intv in geneRangeDict[motifChrom]) #itl.sort() try: startList = [start-1-txWindow for (start,end) in intervalStartDict[motifChrom]] ##-1 changes 1-based encoding into 0-based endList = [end+txWindow for (start,end) in intervalEndDict[motifChrom]] intervalStartList = [(start,end) for (start,end) in intervalStartDict[motifChrom]] intervalEndList = [(start,end) for (start,end) in intervalEndDict[motifChrom]] iStart = bisect(startList, motifEnd) iEnd = bisect(endList, motifStart) s = intervalStartList[:iStart]##bed intervals are 0-based, so overlapping with bed start is not accounted for e = intervalEndList[iEnd:]##motifStart is 1-based, so overlapping with bed end is acccounted for overlapping = list(set(s)&set(e)) #motifInterval = Interval(motifStart, motifEnd) #overlapping = [ x for x in intervals if (x[1]>motifInterval[0] and x[0]<motifInterval[0]) \ #or (x[1]>motifInterval[1] and x[0]<motifInterval[1]) ] #print 'overlapping',overlapping if not len(overlapping) == 0: for x in overlapping: #print x (geneName, transcriptId) = geneRangeDict[motifChrom][x] if not geneName in targetList: targetList.append(geneName) if not (geneName,transcriptId) in transcriptList: transcriptList.append((geneName,transcriptId)) #if len(targetList) > 1: #print targetList, motifChrom, motifInterval except KeyError: pass return targetList, transcriptList
def addValue(self, row, col, size, colour_value): """add a dot in row/col. """ # decide the size of the box pos = bisect.bisect(self.mThresholdsSize, size) if self.mRevertSize: size = self.mMaxBoxSize * \ (1.0 - float(pos) / len(self.mThresholdsSize)) else: size = self.mMaxBoxSize * float(pos) / len(self.mThresholdsSize) d = (self.mMaxBoxSize - size) / 2 x = self.mMapCol2Position[col] + d try: y = self.mMapRow2Position[row] + d except KeyError: return # determine the colour of the box pos = bisect.bisect(self.mThresholdsColour, colour_value) colour = self.mColours[pos] e = SVGdraw.rect(x, y, size, size, stroke="black", fill="rgb(%i,%i,%i)" % colour) self.mElements.append(e)
def _parseindex(self, seq, all): """Internal: parse a message number (or cur, first, etc.).""" if isnumeric(seq): try: return int(seq) except (OverflowError, ValueError): return sys.maxint if seq in ("cur", "."): return self.getcurrent() if seq == "first": return all[0] if seq == "last": return all[-1] if seq == "next": n = self.getcurrent() i = bisect(all, n) try: return all[i] except IndexError: raise Error, "no next message" if seq == "prev": n = self.getcurrent() i = bisect(all, n - 1) if i == 0: raise Error, "no prev message" try: return all[i - 1] except IndexError: raise Error, "no prev message" raise Error, None
def add_geospatial_info(iploc,inbound,outbound,twoway): iplist = '' if os.path.isfile(iploc): iplist = np.loadtxt(iploc,dtype=np.uint32,delimiter=',',usecols={0},\ converters={0: lambda s: np.uint32(s.replace('"',''))}) else: print "No iploc.csv file was found, Map View map won't be created" # get geospatial info, only when iplocation file is available if iplist != '': for srcip in outbound: reader = csv.reader([linecache.getline(\ iploc, bisect.bisect(iplist,outbound[srcip]['ip_int'])).replace('\n','')]) outbound[srcip]['geo'] = reader.next() reader = csv.reader([linecache.getline(\ iploc, bisect.bisect(iplist,outbound[srcip]['dst_ip_int'])).replace('\n','')]) outbound[srcip]['geo_dst'] = reader.next() for dstip in twoway: reader = csv.reader([linecache.getline(\ iploc,bisect.bisect(iplist,twoway[dstip]['ip_int'])).replace('\n','')]) twoway[dstip]['geo'] = reader.next() for srcip in inbound: reader = csv.reader([linecache.getline(\ iploc, bisect.bisect(iplist,inbound[srcip]['ip_int'])).replace('\n','')]) inbound[srcip]['geo'] = reader.next() reader = csv.reader([linecache.getline(\ iploc, bisect.bisect(iplist,inbound[srcip]['src_ip_int'])).replace('\n','')]) inbound[srcip]['geo_src'] = reader.next() return inbound,outbound,twoway
def PlotNode(data,key=None,t0=None,t1=None): from Utility import Time from bisect import bisect import matplotlib.pyplot as plt t = data['times'] if t0 is None: t0i = 0 else: t0i = bisect(t,Time(t0).as_msec()) if t1 is None: t1i = len(t) else: t1i = bisect(t,Time(t1).as_msec())+1 plt.figure() if key is None: N=len(data)-2 i=1 for key,value in data.iteritems(): if key not in ['times','senders']: plt.subplot(N,1,i) plt.plot(t[t0i:t1i],value[t0i:t1i]) plt.xlim(t[t0i],t[t1i-1]) plt.xlabel(key) i=i+1 else: assert(key in data.keys()) plt.plot(t,data[key]) plt.show()
def on_key_press(symbol, modifiers): if symbol == pyglet.window.key.SPACE: # pause / unpause if player.playing: player.pause() else: player.play() elif symbol == pyglet.window.key.LEFT: # jump back 5 seconds player.seek(player.time - 5.0) if player.playing: player.play() elif symbol == pyglet.window.key.RIGHT: # jump forward 5 seconds player.seek(player.time + 5.0) if player.playing: player.play() elif symbol == pyglet.window.key.UP: # jump to shortly before next cut current_segment_idx = bisect(points_of_interest[1:], player.time) try: player.seek(max(points_of_interest[current_segment_idx + 1], 0.0)) if player.playing: player.play() except IndexError: pass elif symbol == pyglet.window.key.DOWN: # jump to shortly before last cut current_segment_idx = bisect(points_of_interest[1:], player.time) if current_segment_idx: if player.time - points_of_interest[current_segment_idx] < 1.0: player.seek(max(points_of_interest[current_segment_idx - 1], 0.0)) else: player.seek(max(points_of_interest[current_segment_idx], 0.0)) else: player.seek(0) if player.playing: player.play()
def searchMatrix(self, matrix, target): line = bisect.bisect([matrix[i][0] for i in xrange(len(matrix))], target) if line > 0: col = bisect.bisect(matrix[line - 1], target) if matrix[line - 1][col - 1] == target: return True return False
def _buildReviewKeys(self, timestamp): """Builds an ordered list of untrained message keys, ready for output in the Review list. Returns a 5-tuple: the keys, the formatted date for the list (eg. "Friday, November 15, 2002"), the start of the prior page or zero if there isn't one, likewise the start of the given page, and likewise the start of the next page.""" # Fetch all the message keys allKeys = state.unknownCorpus.keys() # The default start timestamp is derived from the most recent message, # or the system time if there are no messages (not that it gets used). if not timestamp: if allKeys: timestamp = self._keyToTimestamp(allKeys[-1]) else: timestamp = time.time() start, end, date = self._getTimeRange(timestamp) # Find the subset of the keys within this range. startKeyIndex = bisect.bisect(allKeys, "%d" % long(start)) endKeyIndex = bisect.bisect(allKeys, "%d" % long(end)) keys = allKeys[startKeyIndex:endKeyIndex] keys.reverse() # What timestamps to use for the prior and next days? If there any # messages before/after this day's range, use the timestamps of those # messages - this will skip empty days. prior = end = 0 if startKeyIndex != 0: prior = self._keyToTimestamp(allKeys[startKeyIndex-1]) if endKeyIndex != len(allKeys): end = self._keyToTimestamp(allKeys[endKeyIndex]) # Return the keys and their date. return keys, date, prior, start, end
def _setPAS(self, juman_format): """ 各基本句にPASを設定 """ tag_list = self.tag_list() if juman_format != JUMAN_FORMAT.DEFAULT: for pinfo in self._pinfos: pinfo = json.loads(pinfo) tag_idx = pinfo.get("tid") if tag_idx is None: end = pinfo["head_token_end"] tag_idx = bisect.bisect(self.tag_positions, end) - 1 tag = tag_list[tag_idx] tag.pas = Pas() tag.pas.cfid = pinfo["cfid"] for casename, args in pinfo["args"].items(): for arg in args: arg_tag_idx = arg.get("tid") if arg_tag_idx is None: arg_tag_idx = bisect.bisect(self.tag_positions, arg["head_token_end"]) - 1 arg_sid = arg.get("sid") if (arg_sid is None) or (len(arg["sid"]) == 0): arg_sid = self.sid arg = Argument(sid=arg_sid, tid=arg_tag_idx, midasi=arg["rep"]) tag.pas.arguments[casename].append(arg) else: # KNPの述語項構造をparse for tag in tag_list: if ("格解析結果" in tag.features) or ("述語項構造" in tag.features): tag.pas = Pas(tag.tag_id, self)
def moves(self): if self.next_move is MOVE_TYPE.TOF: min_tof = ASTEROID_TOF[0] max_tof = ASTEROID_TOF[-1] if len(self.tof) < 1: cur_t = T_SCALE[658][self.t0] else: cur_t = T_SCALE[self.seq[-2]][self.tof[-1]] lb = bisect.bisect(T_SCALE[self.seq[-1]], cur_t + min_tof) if (cur_t + max_tof) > (T_SCALE[658][self.t0] + MAX_MISSION_TIME): ub = bisect.bisect(T_SCALE[self.seq[-1]], self.t0 + MAX_MISSION_TIME) else: ub = bisect.bisect(T_SCALE[self.seq[-1]], cur_t + max_tof) return [i for i in range(lb-1, ub)] #return upper and lower bounds on t2 elif self.next_move is MOVE_TYPE.ASTEROID: mov = copy.copy(MOVES[self.next_move]) for ast in self.seq: if ast in mov: mov.remove(ast) return mov else: return MOVES[self.next_move]
def solve(n, i_min, free, curr_board, pieces_left, solutions, fps, se_nh, # Hack to use a fast local variable to avoid a global lookup bisect=bisect): fp_i_cands = fps[i_min] for p in pieces_left: fp_cands = fp_i_cands[p] for fp in fp_cands: if fp <= free: n_curr_board = curr_board[:] for ci in fp: n_curr_board[ci] = p if len(pieces_left) > 1: n_free = free - fp n_i_min = min(n_free) if len(n_free & se_nh[n_i_min]) > 0: n_pieces_left = pieces_left[:] n_pieces_left.remove(p) solve(n, n_i_min, n_free, n_curr_board, n_pieces_left, solutions, fps, se_nh) else: s = ''.join(map(str, n_curr_board)) solutions.insert(bisect(solutions, s), s) rs = s[::-1] solutions.insert(bisect(solutions, rs), rs) if len(solutions) >= n: return if len(solutions) >= n: return
def getPartition(self, key): idx = bisect.bisect(self.keys, key) return len(self.keys) - idx if self.reverse else idx
def __call__(self, offset): if not self.starts: return False q = bisect(self.starts, offset) - 1 return q >= 0 and self.starts[q] <= offset <= self.ends[q]
import bisect value = [14, 85, 77, 77, 26, 50, 45, 66, 79, 10, 3, 84, 77, 1] print('New Pos Contents') print('--- --- --------') l = [] for i in value: position = bisect.bisect(l, i) bisect.insort(l, i) print('{:3} {:3} '.format(i, position), l)
def pos2lineno(pos, offsets): line = bisect(offsets, pos, 0, len(offsets) - 1) if line == 1: offset = pos else: offset = pos - offsets[line - 1] return line, offset
def _choice(population, weights): assert len(population) == len(weights) cdf_vals = _cdf(weights) x = random.random() idx = bisect.bisect(cdf_vals, x) return population[idx]
def tripletsViaBisect(a, b, c): a = sorted(list(set(a))) b = sorted(list(set(b))) c = sorted(list(set(c))) return sum((bisect.bisect(a, x) * bisect.bisect(c, x) for x in b))
def ecdf(x, sample): sample.sort( ) # sample HAS TO BE SORTED in the ASCENDING (NON-DESCENDING) order i = bisect(sample, x) return float(i) / len(sample)
pass # 在readme文件中添加题目 with open("../README.md") as f: data = f.readlines() tData = data[6:] insertData = [ID, '[' + name + ']' + '(' + url + ')', 'c'] for p in prog[1:]: fileName = './src/' + dirName + '/' + ID + '.' + p if p == 'cpp': p = 'c++' elif p == 'py': p = 'python' insertData.append('[' + p + ']' + '(' + fileName + ')') insertData.append(difficult) insertData = '|' + '|'.join(insertData) + '|' index = bisect.bisect(tData, insertData) if index == len(tData): insertData = '\n' + insertData else: insertData += '\n' target_org_str, insert_org_str = tData[index - 1].strip( "\n")[:6], insertData.strip("\n")[:6] if target_org_str != insert_org_str: tData.insert(index, insertData) with open("../README.md", 'w') as f: f.writelines(data[:6] + tData)
def __new__(cls, value): index = bisect(cls.breakpoints, value) score = cls.scores[index] score_col = colors.fg(cls.colors_[index]) score = '[' + score.center(cls.max_scores_len) + ']' return score_col | score
def __call__( self, q_event_sequence: QEventSequence, grace_handler: GraceHandler | None = None, heuristic: Heuristic | None = None, job_handler: JobHandler | None = None, attack_point_optimizer: AttackPointOptimizer | None = None, attach_tempos: bool = True, ): """ Calls q-target. """ assert isinstance(q_event_sequence, QEventSequence) if grace_handler is None: grace_handler = ConcatenatingGraceHandler() assert isinstance(grace_handler, GraceHandler) if heuristic is None: heuristic = DistanceHeuristic() assert isinstance(heuristic, Heuristic) if job_handler is None: job_handler = SerialJobHandler() assert isinstance(job_handler, JobHandler) if attack_point_optimizer is None: attack_point_optimizer = NaiveAttackPointOptimizer() assert isinstance(attack_point_optimizer, AttackPointOptimizer) if isinstance(self, BeatwiseQTarget) and isinstance( attack_point_optimizer, MeasurewiseAttackPointOptimizer): message = "{} is not supposed to be used together with {}.".format( self.__class__.__name__, attack_point_optimizer.__class__.__name__) raise TypeError(message) # TODO: this step seems unnecessary now (23/09/2021), (maybe) write more tests to verify # if next-to-last QEvent is silent, pop the TerminalQEvent, # in order to prevent rest-tuplets # q_events = q_event_sequence # if isinstance(q_event_sequence[-2], SilentQEvent): # q_events = q_event_sequence[:-1] # parcel QEvents out to each beat beats = self.beats offsets = sorted([beat.offset_in_ms for beat in beats]) for q_event in q_event_sequence: index = bisect.bisect(offsets, q_event.offset) - 1 beat = beats[index] beat.q_events.append(q_event) # generate QuantizationJobs and process with the JobHandler jobs = [beat(i) for i, beat in enumerate(beats)] jobs = [job for job in jobs if job] jobs = job_handler(jobs) for job in jobs: assert job is not None beats[job.job_id]._q_grids = job.q_grids # for i, beat in enumerate(beats): # print i, len(beat.q_grids) # for q_event in beat.q_events: # print '\t{}'.format(q_event.offset) # select the best QGrid for each beat, according to the Heuristic beats = heuristic(beats) # shift QEvents attached to each QGrid's "next downbeat" # over to the next QGrid's first leaf - the real downbeat orphaned_q_events_proxies = self._shift_downbeat_q_events_to_next_q_grid( ) # TODO: handle a final QGrid with QEvents attached to its # next_downbeat. # TODO: remove a final QGrid with no QEvents self._regroup_q_grid_with_unnecessary_divisions() # convert the QGrid representation into notation, # handling grace-note behavior with the GraceHandler notation = self._notate( attach_tempos=attach_tempos, attack_point_optimizer=attack_point_optimizer, grace_handler=grace_handler, ) handle_orphaned_q_events = getattr(grace_handler, "handle_orphaned_q_event_proxies", None) if callable(handle_orphaned_q_events) and orphaned_q_events_proxies: last_leaf = abjad.get.leaf(notation, -1) handle_orphaned_q_events(last_leaf, orphaned_q_events_proxies) return notation
currentBattery = matchObj.group(2) if (currentBattery != previousBattery): previousBattery = currentBattery datetime_obj = datetime.strptime(matchObj.group(1), "%b %d,%Y %H:%M:%S") batteryChangeIntervals.append(datetime_obj) #print currentBattery, " ", matchObj.group(1) batteryChangeIntervals.append(end_datetime) previous_datetime = start_datetime next_datetime = start_datetime + timedelta(seconds=interval) #print start_datetime, " ", next_datetime, " ", end_datetime #print len(batteryChangeIntervals), end_datetime intervalBatteryFraction = [] while (next_datetime <= end_datetime): i = bisect.bisect(batteryChangeIntervals, previous_datetime) j = bisect.bisect(batteryChangeIntervals, next_datetime) #print previous_datetime, " ", i, " ", next_datetime, " ", j lenBatteryChangeIntervals = len(batteryChangeIntervals) if (i == j and (next_datetime == batteryChangeIntervals[lenBatteryChangeIntervals - 2] or j < (lenBatteryChangeIntervals - 1))): #print previous_datetime, " ", i, " ", i-1 batteryduration = batteryChangeIntervals[i] - batteryChangeIntervals[ i - 1] fraction = interval / batteryduration.total_seconds() print fraction intervalBatteryFraction.append(fraction) elif ( i == j - 1 and (next_datetime == batteryChangeIntervals[lenBatteryChangeIntervals - 2]
def color(cls, value): """task value/score color""" index = bisect(cls.breakpoints, value) return colors.fg(cls.colors_[index])
def select_crossover(self): # Implementation from https://docs.python.org/3/library/random.html -- Ctrl+F "weights" choices, weights = zip(*self.crossovers.items()) cumdist = list(accumulate(weights)) x = random.random() * cumdist[-1] self.selected_crossover = choices[bisect(cumdist, x)]
class Folder: """Class representing a particular folder.""" def __init__(self, mh, name): """Constructor.""" self.mh = mh self.name = name if not os.path.isdir(self.getfullname()): raise Error, 'no folder %s' % name def __repr__(self): """String representation.""" return 'Folder(%s, %s)' % (`self.mh`, `self.name`) def error(self, *args): """Error message handler.""" apply(self.mh.error, args) def getfullname(self): """Return the full pathname of the folder.""" return os.path.join(self.mh.path, self.name) def getsequencesfilename(self): """Return the full pathname of the folder's sequences file.""" return os.path.join(self.getfullname(), MH_SEQUENCES) def getmessagefilename(self, n): """Return the full pathname of a message in the folder.""" return os.path.join(self.getfullname(), str(n)) def listsubfolders(self): """Return list of direct subfolders.""" return self.mh.listsubfolders(self.name) def listallsubfolders(self): """Return list of all subfolders.""" return self.mh.listallsubfolders(self.name) def listmessages(self): """Return the list of messages currently present in the folder. As a side effect, set self.last to the last message (or 0).""" messages = [] match = numericprog.match append = messages.append for name in os.listdir(self.getfullname()): if match(name): append(name) messages = map(int, messages) messages.sort() if messages: self.last = messages[-1] else: self.last = 0 return messages def getsequences(self): """Return the set of sequences for the folder.""" sequences = {} fullname = self.getsequencesfilename() try: f = open(fullname, 'r') except IOError: return sequences while 1: line = f.readline() if not line: break fields = line.split(':') if len(fields) != 2: self.error('bad sequence in %s: %s' % (fullname, line.strip())) key = fields[0].strip() value = IntSet(fields[1].strip(), ' ').tolist() sequences[key] = value return sequences def putsequences(self, sequences): """Write the set of sequences back to the folder.""" fullname = self.getsequencesfilename() f = None for key in sequences.keys(): s = IntSet('', ' ') s.fromlist(sequences[key]) if not f: f = open(fullname, 'w') f.write('%s: %s\n' % (key, s.tostring())) if not f: try: os.unlink(fullname) except os.error: pass else: f.close() def getcurrent(self): """Return the current message. Raise Error when there is none.""" seqs = self.getsequences() try: return max(seqs['cur']) except (ValueError, KeyError): raise Error, "no cur message" def setcurrent(self, n): """Set the current message.""" updateline(self.getsequencesfilename(), 'cur', str(n), 0) def parsesequence(self, seq): """Parse an MH sequence specification into a message list. Attempt to mimic mh-sequence(5) as close as possible. Also attempt to mimic observed behavior regarding which conditions cause which error messages.""" # XXX Still not complete (see mh-format(5)). # Missing are: # - 'prev', 'next' as count # - Sequence-Negation option all = self.listmessages() # Observed behavior: test for empty folder is done first if not all: raise Error, "no messages in %s" % self.name # Common case first: all is frequently the default if seq == 'all': return all # Test for X:Y before X-Y because 'seq:-n' matches both i = seq.find(':') if i >= 0: head, dir, tail = seq[:i], '', seq[i+1:] if tail[:1] in '-+': dir, tail = tail[:1], tail[1:] if not isnumeric(tail): raise Error, "bad message list %s" % seq try: count = int(tail) except (ValueError, OverflowError): # Can't use sys.maxint because of i+count below count = len(all) try: anchor = self._parseindex(head, all) except Error, msg: seqs = self.getsequences() if not seqs.has_key(head): if not msg: msg = "bad message list %s" % seq raise Error, msg, sys.exc_info()[2] msgs = seqs[head] if not msgs: raise Error, "sequence %s empty" % head if dir == '-': return msgs[-count:] else: return msgs[:count] else: if not dir: if head in ('prev', 'last'): dir = '-' if dir == '-': i = bisect(all, anchor) return all[max(0, i-count):i] else: i = bisect(all, anchor-1) return all[i:i+count] # Test for X-Y next i = seq.find('-') if i >= 0: begin = self._parseindex(seq[:i], all) end = self._parseindex(seq[i+1:], all) i = bisect(all, begin-1) j = bisect(all, end) r = all[i:j] if not r: raise Error, "bad message list %s" % seq return r # Neither X:Y nor X-Y; must be a number or a (pseudo-)sequence try: n = self._parseindex(seq, all) except Error, msg: seqs = self.getsequences() if not seqs.has_key(seq): if not msg: msg = "bad message list %s" % seq raise Error, msg return seqs[seq]
def decode(y): #------------------------------------------------------------------------------------ #INITIALISAITION #------------------------------------------------------------------------------------ #implementing Laplace estimator, intialising frequencies range frequencies = [] for i in range(kappa): frequencies.append({}) frequencies[0]['escape'] = 1 #frequencies have the following structure: frequencies[number of context alphabets][context name][alphabet][frequency] #initialising precisions precision = 32 one = int(2**precision - 1) quarter = int(ceil(one / 4)) half = 2 * quarter threequarters = 3 * quarter y.extend(precision * [0]) # dummy zeros to prevent index out of bound errors x = [] a = [''] * kappa # initialise by taking first 'precision' bits from y and converting to a number value = int(''.join(str(a) for a in y[0:precision]), 2) position = precision # position where currently reading y lo, hi = 0, one # initialise lo and hi to be [0,1.0) #------------------------------------------------------------------------------------ #CALCULATION #------------------------------------------------------------------------------------ while True: # for every symbol p = update_prob(frequencies, a) f = update_culm_prob_dec(p) #print(f) lohi_range = hi - lo + 1 decoded_symbol = bisect(f, (value - lo) / lohi_range) - 1 a.insert(0, decoded_symbol) #print(chr(decoded_symbol)) if len(a) > kappa: a.pop(-1) # debugging #print(a[0]) lo = lo + int(ceil(f[a[0]] * lohi_range)) hi = lo + int(floor(p[a[0]] * lohi_range)) if (lo > one or hi > one): raise ValueError('Probabilities greater than one!') if (lo == hi): raise NameError('Zero interval!') while True: if hi < half: # do nothing pass elif lo >= half: lo = lo - half hi = hi - half value = value - half elif lo >= quarter and hi < threequarters: lo = lo - quarter hi = hi - quarter value = value - quarter else: break lo = 2 * lo hi = 2 * hi + 1 value = 2 * value + y[position] position += 1 if position >= len(y): return (x) #------------------------------------------------------------------------------------ #UPDATE #------------------------------------------------------------------------------------ x.append(decoded_symbol) update_freq(a, frequencies) #debugging # if len(x) <= 10: # print(x[-1]) # print(a) # print(frequencies) return ("Compression Failed")
def __search_index(self, x): """ search data segment index """ return bisect.bisect(self.x, x) - 1
def CalcSolarPosition(lat, lon, hour, min, sec, offset, JDC, radial_samples): toRadians = pi/180.0 toDegrees = 180.0/pi MeanObliquity = 23.0 + (26.0 + ((21.448 - JDC * (46.815 + JDC * (0.00059 - JDC * 0.001813))) / 60.0)) / 60.0 Obliquity = MeanObliquity + 0.00256 * cos(toRadians*(125.04 - 1934.136 * JDC)) Eccentricity = 0.016708634 - JDC * (0.000042037 + 0.0000001267 * JDC) GeoMeanLongSun = 280.46646 + JDC * (36000.76983 + 0.0003032 * JDC) while GeoMeanLongSun < 0: GeoMeanLongSun += 360 while GeoMeanLongSun > 360: GeoMeanLongSun -= 360 GeoMeanAnomalySun = 357.52911 + JDC * (35999.05029 - 0.0001537 * JDC) Dummy1 = toRadians*GeoMeanAnomalySun Dummy2 = sin(Dummy1) Dummy3 = sin(Dummy2 * 2) Dummy4 = sin(Dummy3 * 3) SunEqofCenter = Dummy2 * (1.914602 - JDC * (0.004817 + 0.000014 * JDC)) + Dummy3 * (0.019993 - 0.000101 * JDC) + Dummy4 * 0.000289 SunApparentLong = (GeoMeanLongSun + SunEqofCenter) - 0.00569 - 0.00478 * sin(toRadians*((125.04 - 1934.136 * JDC))) Dummy1 = sin(toRadians*Obliquity) * sin(toRadians*SunApparentLong) Declination = toDegrees*(atan(Dummy1 / sqrt(-Dummy1 * Dummy1 + 1))) SunRadVector = (1.000001018 * (1 - pow(Eccentricity,2))) / (1 + Eccentricity * cos(toRadians*(GeoMeanAnomalySun + SunEqofCenter))) #====================================================== #Equation of time (minutes) Dummy = pow((tan(Obliquity * pi / 360)),2) Dummy1 = sin(toRadians*(2 * GeoMeanLongSun)) Dummy2 = sin(toRadians*(GeoMeanAnomalySun)) Dummy3 = cos(toRadians*(2 * GeoMeanLongSun)) Dummy4 = sin(toRadians*(4 * GeoMeanLongSun)) Dummy5 = sin(toRadians*(2 * GeoMeanAnomalySun)) Et = toDegrees*(4 * (Dummy * Dummy1 - 2 * Eccentricity * Dummy2 + 4 * Eccentricity * Dummy * Dummy2 * Dummy3 - 0.5 * pow(Dummy,2) * Dummy4 - 1.25 * pow(Eccentricity,2) * Dummy5)) SolarTime = (hour*60.0) + min + (sec/60.0) + (Et - 4.0 * -lon + (offset*60.0)) while SolarTime > 1440.0: SolarTime -= 1440.0 HourAngle = SolarTime / 4.0 - 180.0 if HourAngle < -180.0: HourAngle += 360.0 Dummy = sin(toRadians*lat) * sin(toRadians*Declination) + cos(toRadians*lat) * cos(toRadians*Declination) * cos(toRadians*HourAngle) if Dummy > 1.0: Dummy = 1.0 elif Dummy < -1.0: Dummy = -1.0 Zenith = toDegrees*(acos(Dummy)) Dummy = cos(toRadians*lat) * sin(toRadians*Zenith) if abs(Dummy) >= 0.000999: Azimuth = (sin(toRadians*lat) * cos(toRadians*Zenith) - sin(toRadians*Declination)) / Dummy if abs(Azimuth) > 1.0: if Azimuth < 0: Azimuth = -1.0 else: Azimuth = 1.0 Azimuth = 180 - toDegrees*(acos(Azimuth)) if HourAngle > 0: Azimuth *= -1.0 else: if lat > 0: Azimuth = 180.0 else: Azimuth = 0.0 if Azimuth < 0: Azimuth += 360.0 AtmElevation = 90 - Zenith if AtmElevation > 85: RefractionCorrection = 0 else: Dummy = tan(toRadians*(AtmElevation)) if AtmElevation > 5: RefractionCorrection = 58.1 / Dummy - 0.07 / pow(Dummy,3) + 0.000086 / pow(Dummy,5) elif AtmElevation > -0.575: RefractionCorrection = 1735 + AtmElevation * (-518.2 + AtmElevation * (103.4 + AtmElevation * (-12.79 + AtmElevation * 0.711))) else: RefractionCorrection = -20.774 / Dummy RefractionCorrection = RefractionCorrection / 3600 Zenith = Zenith - RefractionCorrection Altitude = 90 - Zenith Daytime = 0 if Altitude > 0.0: Daytime = 1 if radial_samples == -999: #-999 is a code indicating that the numver of radial samples was blank, so we assumed old methods. dir = bisect((0.0,67.5,112.5,157.5,202.5,247.5,292.5),Azimuth)-1 else: #using terms from GIS sampling routine WedgeZones = radial_samples Angle_Incr = 360.0 / WedgeZones WedgeNumbers = range(1,WedgeZones) WedgeAngleStart = [x*Angle_Incr-Angle_Incr/2 for x in WedgeNumbers] if Azimuth < WedgeAngleStart[0]: Azimuth_mod = Azimuth + 360 else: Azimuth_mod = Azimuth dir = bisect(WedgeAngleStart,Azimuth_mod)-1 return Altitude, Zenith, Daytime, dir
def get_daily_backlog_history(self, start_date, end_date): """ returns list of tuple (date,stats) date is date value in epoc time stats is dictionary of {'created':[], 'opened':[], 'closed':[]} """ # this is array of date in numpy numdates = drange(start_date, end_date + timedelta(days=1), timedelta(days=1)) # for date in numdates: # self.env.log.info(num2date(date)) end_date = end_date.replace(hour=23, minute=59, second=59) # each key is the list of list of ticket. The index of the list is corresponding # to the index of the date in numdates list. backlog_stats = {'created': [], 'opened': [], 'closed': []} # initialize backlog_stats for date in numdates: for key in backlog_stats: backlog_stats[key].append([]) # start by getting the list of opened ticket at the end of the start date. backlog_stats['opened'][0] = self.get_remaning_opened_ticket_on( start_date) for ticket in self.tickets: # only consider the ticket that was created before end dates. if ticket.time_created <= end_date: # only track the ticket that create since start_date if ticket.time_created >= start_date: # determine index date = ticket.time_created.date() #get index of day in the dates list index = bisect(numdates, date2num(date)) - 1 # add ticket created ticket list backlog_stats['created'][index].append(ticket.id) for t, author, field, oldvalue, newvalue, permanent in ticket.get_changelog( ): # determine index date = t.date() #get index of day in the dates list index = bisect(numdates, date2num(date)) - 1 if field == 'status' and start_date <= t <= end_date: if newvalue == 'closed': # add ticket created ticket list backlog_stats['closed'][index].append(ticket.id) elif newvalue == 'reopen': backlog_stats['opened'][index].append(ticket.id) # update opened ticket list for idx, list in enumerate(backlog_stats['opened']): if idx > 0: # merge list of opened ticket from previous day list.extend(backlog_stats['opened'][idx - 1]) # add created ticket to opened ticket list list.extend(backlog_stats['created'][idx]) # remove closed ticket from opened ticket list. for id in backlog_stats['closed'][idx]: try: list.remove(id) except ValueError, e: pass list.sort()
def get(self): r = random.random() * self.total_weight index = bisect.bisect(self.cumulative_weights, r) return self.net._edges[index]
def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'): i = bisect.bisect(breakpoints, score) return grades[i]
def stratum_idx_for_score(self, x): return bisect.bisect(self.bounds, x) - 1
def weighted_sampler(seq, weights): "Return a random-sample function that picks from seq weighted by weights." totals = [] for w in weights: totals.append(w + totals[-1] if totals else w) return lambda: seq[bisect.bisect(totals, random.uniform(0, totals[-1]))]
from bisect import bisect_right,bisect C, D = map( int, input().split()) m = C//140 M = D//170 ans = 0 L = [] for i in range(1,6): L.append(140*i) L.append(170*i) S = [30*i for i in range(1,6)] if C >= 140*6: ans = D - C elif D >= 170*5: else: k = bisect_right(L,C) u = bisect(L,D) if k%2 == 0: if u%2 == 1: for i in range(k/2+1,(u+1)/2): ans += 30*i else:
def parent_selection(accum): s = set() while len(s) < 2: s.add(bisect(accum, random())) return tuple(s)
def bisect_in(seq, item): pos = bisect(seq, item) return seq[pos - 1] == item if seq else False
def uniform_strata_method(scores, n_strata): bounds = [i / n_strata for i in range(n_strata + 1)] allocations = [bisect.bisect(bounds, x) - 1 for x in scores] print(Counter(allocations)) return allocations, bounds
def from_pcm(cls, filename, pcmreader, compression=None, total_pcm_frames=None): from audiotools import __default_quality__ from audiotools import PCMConverter from audiotools import ChannelMask from audiotools.encoders import encode_mpc if (compression is None) or (compression not in cls.COMPRESSION_MODES): compression = __default_quality__(cls.NAME) if pcmreader.bits_per_sample not in {8, 16, 24}: from audiotools import UnsupportedBitsPerSample pcmreader.close() raise UnsupportedBitsPerSample(filename, pcmreader.bits_per_sample) if pcmreader.sample_rate in (32000, 37800, 44100, 48000): sample_rate = pcmreader.sample_rate if total_pcm_frames is not None: from audiotools import CounterPCMReader pcmreader = CounterPCMReader(pcmreader) else: from bisect import bisect sample_rate = [32000, 32000, 37800, 44100, 48000][bisect([32000, 37800, 44100, 4800], pcmreader.sample_rate)] total_pcm_frames = None try: encode_mpc( filename, PCMConverter(pcmreader, sample_rate=sample_rate, channels=min(pcmreader.channels, 2), channel_mask=int( ChannelMask.from_channels( min(pcmreader.channels, 2))), bits_per_sample=16), float(compression), total_pcm_frames if (total_pcm_frames is not None) else 0) # ensure PCM frames match, if indicated if ((total_pcm_frames is not None) and (total_pcm_frames != pcmreader.frames_written)): from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH from audiotools import EncodingError raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH) return MPCAudio(filename) except (IOError, ValueError) as err: from audiotools import EncodingError cls.__unlink__(filename) raise EncodingError(str(err)) except Exception: cls.__unlink__(filename) raise finally: pcmreader.close()
def get_example(self, i): tgt = bisect.bisect(self._zpaths_accumlens, i) - 1 lidx = i - self._zpaths_accumlens[tgt] return self._zfs[tgt].get_example(lidx)
def __complete_braces(self, event): """Complete () [] and {} using a mild inteligence to see if corresponds and also do some more magic such as complete in classes and functions. """ brace = event.text() if brace not in settings.BRACES: # Thou shalt not waste cpu cycles if this brace compleion dissabled return line, index = self.getCursorPosition() text = self.text(line) complementary_brace = BRACE_DICT.get(brace) token_buffer = [] _, tokens = self.__tokenize_text(text) is_unbalance = 0 for tkn_type, tkn_rep, tkn_begin, tkn_end in tokens: if tkn_rep == brace: is_unbalance += 1 elif tkn_rep == complementary_brace: is_unbalance -= 1 if tkn_rep.strip() != "": token_buffer.append((tkn_rep, tkn_end[1])) is_unbalance = (is_unbalance >= 0) and is_unbalance or 0 if (self.lang == "python") and (len(token_buffer) == 3) and \ (token_buffer[2][0] == brace) and (token_buffer[0][0] in ("def", "class")): self.insertAt("):", line, index) # are we in presence of a function? # TODO: IMPROVE THIS AND GENERALIZE IT WITH INTELLISENSEI if token_buffer[0][0] == "def": symbols_handler = handlers.get_symbols_handler('py') split_source = self.text().split("\n") indent = re.match('^\\s+', str(split_source[line])) indentation = (indent.group() + " " * self._indent if indent is not None else " " * self._indent) new_line = "%s%s" % (indentation, 'pass') split_source.insert(line + 1, new_line) source = '\n'.join(split_source) source = source.encode(self.encoding) _, symbols_simplified = symbols_handler.obtain_symbols( source, simple=True, only_simple=True) symbols_index = sorted(symbols_simplified.keys()) symbols_simplified = sorted( list(symbols_simplified.items()), key=lambda x: x[0]) index_symbol = bisect.bisect(symbols_index, line) if (index_symbol >= len(symbols_index) or symbols_index[index_symbol] > (line + 1)): index -= 1 belongs_to_class = symbols_simplified[index_symbol][1][2] if belongs_to_class: self.insertAt("self", line, index) index += 4 if self.selected_text != "": self.insertAt(", ", line, index) index += 2 self.insertAt(self.selected_text, line, index) self.setCursorPosition(line, index) elif (token_buffer and (not is_unbalance) and self.selected_text): self.insertAt(self.selected_text, line, index) elif is_unbalance: next_char = text[index:index + 1].strip() if self.selected_text or next_char == "": self.insertAt(complementary_brace, line, index) self.insertAt(self.selected_text, line, index)
def __getitem__(self, i): if not 0 <= i < len(self): raise IndexError(i) return self.population[bisect.bisect(self.cumweights, i)]