def find_closest_elements_in_sorted_arrays(sorted_arrays): # TODO - you fill in here. min_diff = float('inf') chosen_set = [] iters = SortedDict() for idx, s in enumerate(sorted_arrays): it = iter(s) first_min = next(it, None) assert first_min is not None, pdb.set_trace() if first_min is not None: iters[first_min] = (idx, it) while True: max_val = iters.keys()[-1] min_val, (min_idx, it) = iters.peekitem(0) if min_diff > max_val - min_val: min_diff = max_val - min_val chosen_set = sorted(list((v, i) for v, (i, _) in iters.items()), key=lambda x: x[1]) iters.popitem(0) next_min = next(it, None) if next_min == None: print(chosen_set) return min_diff iters[next_min] = (min_idx, it) assert len(iters) == len(sorted_arrays), pdb.set_trace()
def compute(N, K): lst = SortedDict() def lst_add(length, mult): if length in lst: oldval = lst[length] lst[length] = oldval + mult else: lst[length] = mult def lst_rem(length, mult=-1): if mult == -1: mult = lst[length] if length in lst: if lst[length] == mult: del lst[length] else: oldval = lst[length] lst[length] = oldval - mult else: raise ValueError lst[N] = 1 i = 1 while i < K: left = K - i t = lst.popitem() lent = t[0] # length mult = t[1] use = min(left, mult) new_length1 = int(floor((lent - 1) / 2)) new_length2 = int(ceil((lent - 1) / 2)) if new_length1 > 0: lst_add(new_length1, use) if new_length2 > 0: lst_add(new_length2, use) if use < mult: lst_add(lent, mult - use) i += use t = lst.popitem() tl = t[0] new_length1 = int(floor((tl - 1) / 2)) new_length2 = int(ceil((tl - 1) / 2)) return (max(new_length1, new_length2), min(new_length1, new_length2))
class SortedSlidingDic: def __init__(self, stime): self.flow_dic = {} self.ts_dic = SortedDict() self.stime = float(self.unified_ts(stime)) def unified_ts(self, ts): return round(ts, 10) def update(self, ts): ts = self.unified_ts(ts) while len(self.ts_dic) > 0 and ts - self.ts_dic.peekitem(0)[0] > self.stime: del self.flow_dic[self.ts_dic.peekitem(0)[1]] self.ts_dic.popitem(0) def add(self, flow, ts): ts = self.unified_ts(ts) # Remove the previous timestamp for this flow and the new one instead self.remove(flow) self.flow_dic[flow] = ts if ts in self.ts_dic: del self.flow_dic[self.ts_dic[ts]] self.ts_dic[ts] = flow assert len(self.flow_dic) == len(self.ts_dic) def remove(self, flow): if flow in self.flow_dic: ts = self.flow_dic[flow] try: del self.flow_dic[flow] self.ts_dic.pop(ts) except KeyError: print 'KeyError ', flow, ts def __str__(self): res = '' for k in self.ts_dic: res += str("%.10f" % k)+'\t'+str(self.ts_dic[k])+'\n' print res
def stalls(n_stalls, n_people): # depth = int(math.log(n_people, 2)) stall_counts = SortedDict() add_count(stall_counts, n_stalls, 1) n_p = n_people while n_p > 0: if len(stall_counts) <= 0: error("0") return 0, 0 # print("{}\t{}".format(n_p, stall_counts)) n_s, count = stall_counts.popitem() n_p -= count min_d = (n_s - 1) // 2 max_d = (n_s - 1) - min_d if n_p <= 0: # if n_p < 0: # error(n_p) return max_d, min_d add_count(stall_counts, min_d, count) add_count(stall_counts, max_d, count)
def to_lyndon_basis( words, # Linear[word] ): assert isinstance(words, Linear) terms_to_convert = SortedDict(words.items()) terms_converted = Linear() while terms_to_convert: word_orig, coeff = terms_to_convert.popitem(-1) lyndon_words = lyndon_factorize(word_orig) assert len(lyndon_words) > 0 lyndon_word_expr = Linear.count(lyndon_words) if len(lyndon_words) == 1: terms_converted[word_orig] += coeff continue denominator = 1 for _, count in lyndon_word_expr.items(): denominator *= math.factorial(count) expanded_word_expr = Linear.count( shuffle_product(lyndon_words)).div_int(denominator) assert expanded_word_expr[ word_orig] == 1, f"{word_orig} not in {expanded_word_expr}" # print(f"Lyndon transform: {word_orig} => {lyndon_words} =>\n{expanded_word_expr}") expanded_word_expr[word_orig] = 0 for word, inner_coeff in expanded_word_expr.items(): assert terms_converted[word] == 0 if not word in terms_to_convert: terms_to_convert[word] = 0 terms_to_convert[word] -= coeff * inner_coeff return terms_converted
class SDWaitQueue(Generic[K, V]): __slots__ = ('_data', ) def __init__(self): self._data = SortedDict() # type: SortedDict[K, deque[V]] def __bool__(self): return bool(self._data) def __len__(self): return sum(len(item) for item in self._data.values()) def push(self, key: K, item: V): try: self._data[key].append(item) except KeyError: self._data[key] = elements = deque() # type: deque[V] elements.append(item) def pop(self) -> 'Tuple[K, deque[V]]': return self._data.popitem(0) def __repr__(self): return '<SDWaitQueue [%s]>' % ''.join( '%s: %s' % (key, value) for key, value in self._data.items())
def runsimulation(t_max, males, F_per_M, females,female_visit_param, dist, bird_speed, improb_sds,improb_dist,FG_tau_mean, FG_tau_std,FG_tau_range, FG_tau_norm_range,FG_k, FG_theta, FG_divisor,RBSB_tau_mean, RBSB_tau_std, RBSB_tau_norm_range, damage_to_bower, male_pos, male_strat): global birds global timeline global female_birds timeline = SortedDict() # BIRDS birds = [] # initialize positions, travel times and preferences distances, travel_times = compute_distances_travel_times(males, male_pos, bird_speed, dist) visit_preferences = compute_visit_preferences(males, distances, improb_dist, improb_sds) for i in range(males): birds.append(initialize_male(i, male_strat[i], male_pos[i], visit_preferences[i], travel_times[i])) # choose its first action choose_action(birds[-1], 0.0) #initialize females female_birds=[] for i in range(females): #females female_id = "F" + str(i) female_birds.append(initialize_female(female_id, males)) #female IDs start where males end (if there are 10 males, the first female would be 11) #choose time for initial mating attempt first_time = female_visit_param[0] * truncnorm.rvs(female_visit_param[2], female_visit_param[3]) + female_visit_param[1] action_mating_attempt(female_id, first_time) # this is the main loop (for one mating season) while len(timeline) > 0: current_ticket = timeline.popitem(0) read_ticket(current_ticket[1]) return birds
def find_closest_elements_in_sorted_arrays(sorted_arrays): # TODO - you fill in here. min_diff = float('inf') iters = SortedDict() chosen_set = None for idx, s in enumerate(sorted_arrays): it = iter(s) first_min = next(it, None) if first_min is not None: iters[(first_min, idx)] = it while True: max_val = iters.keys()[-1][0] min_val, min_idx = iters.keys()[0] if min_diff > max_val - min_val: min_diff = max_val - min_val chosen_set = sorted(list(iters.keys()), key=lambda x: x[1]) it = iters.popitem(0)[1] next_min = next(it, None) if next_min == None: print(chosen_set) return min_diff iters[(next_min, min_idx)] = it assert len(iters) == len(sorted_arrays), pdb.set_trace()
class SortedDictBook: def __init__(self, depth): self.depth = depth self.orders = SortedDict() self.empty_price = PriceUpdate() def update(self, price_update: PriceUpdate) -> bool: action = { 48: self.new_order, 49: self.update_order, 50: self.delete_order, 51: self.delete_thru, 52: self.delete_from }.get(price_update.action, None) if action: action(price_update) return True return False def update_order(self, price_update: PriceUpdate): self.orders[price_update.price] = price_update def delete_order(self, price_update: PriceUpdate): self.orders.pop(price_update.price) def delete_thru(self, price_update: PriceUpdate): self.orders.clear() def new_order(self, price_update: PriceUpdate): if len(self.orders) == self.depth: self.orders.popitem() self.orders[price_update.price] = price_update def get_book(self) -> List[PriceUpdate]: return self.orders.values() def delete_from(self, price_update: PriceUpdate): direction = price_update.level del self.orders.iloc[:direction] def top(self) -> PriceUpdate: return self.orders.peekitem(0)[1] if self.orders else self.empty_price
def k_most_visited(stream, k): sorted_dict = SortedDict() for page in stream: if page not in sorted_dict: sorted_dict[page] = 1 else: sorted_dict[page] += 1 return [sorted_dict.popitem(index=0) for x in range(k)]
class RangeModule: def __init__(self): self.data = SortedDict() def addRange(self, left: int, right: int) -> None: l, r = self.data.bisect(left), self.data.bisect(right) if l != 0: # move L to the left by 1 this will point to the lower bound l -= 1 # if the left is larger than the previous interval we need to move it up if self.data.peekitem(l)[1] < left: l += 1 if l != r: # given the adjust left and right intervals we need to check if a merge needs to happen. we take # the min of the left intervals and the max of the right intervals to maximize the interval size. left, right = min(left, self.data.peekitem(l)[0]), max(right, self.data.peekitem(r-1)[1]) # now that we have the new interval we need ot pop the redundant intervals for _ in range(l, r): self.data.popitem(l) # insert the new interval self.data[left] = right print(self.data) def queryRange(self, left: int, right: int) -> bool: l, r = self.data.bisect_right(left), self.data.bisect_right(right) print("l == 0: ",(l == 0), "self.data.peekitem(l-1)[1] < right: ",(self.data.peekitem(l-1)[1] < right)) if l == 0 or self.data.peekitem(l-1)[1] < right: return False return True def removeRange(self, left: int, right: int) -> None: l, r = self.data.bisect_right(left), self.data.bisect_right(right) if l != 0: l -= 1 if self.data.peekitem(l)[1] < left: l += 1 if l != r: ll, rr = min(left, self.data.peekitem(l)[0]), max(right, self.data.peekitem(r-1)[1]) for _ in range(l, r): self.data.popitem(l) if ll < left: self.data[ll] = left if right < rr: self.data[right] = rr
class LFUCache: def __init__(self, capacity: int): self.capacity = capacity self.capUsage = 0 self.keyValue = {} self.keyCnt = {} self.cntKey = SortedDict() def get(self, key: int) -> int: # print(f"get {key} ") # print("keyCnt ",self.keyCnt) # print("cnt ", self.cntKey) if self.capacity == 0 or key not in self.keyValue: return -1 ret = self.keyValue[key] ntimes = self.keyCnt[key] self.cntKey[ntimes + 1] = self.cntKey.get(ntimes + 1, OrderedDict()) self.cntKey[ntimes + 1][key] = 1 self.keyCnt[key] += 1 del self.cntKey[ntimes][key] if len(self.cntKey[ntimes]) == 0: del self.cntKey[ntimes] # print("keyCnt: ", self.keyCnt) # print("cntKey: ", self.cntKey) return ret def put(self, key: int, value: int) -> None: # print(f"put {key} ") # print("keyCnt: ", self.keyCnt) # print("cnt: ", self.cntKey) if self.capacity == 0: return None if key in self.keyValue: self.get(key) self.keyValue[key] = value ## delete least freq used else: if self.capUsage == self.capacity: ntimes, ndict = self.cntKey.popitem(0) self.capUsage -= 1 oldKey, _ = ndict.popitem(last=False) del self.keyCnt[oldKey] del self.keyValue[oldKey] if ndict: self.cntKey[ntimes] = ndict self.capUsage += 1 self.keyValue[key] = value self.keyCnt[key] = 1 self.cntKey[1] = self.cntKey.get(1, OrderedDict()) self.cntKey[1][key] = 1
class RangeModuleDict: def __init__(self): self.data = SortedDict() def addRange(self, left: int, right: int) -> None: l = self.data.bisect(left) r = self.data.bisect(right) if l != 0: l -= 1 if self.data.peekitem(l)[1] < left: l += 1 if l != r: left = min(left, self.data.peekitem(l)[0]) right = max(right, self.data.peekitem(r - 1)[1]) for _ in range(l, r): self.data.popitem(l) self.data[left] = right def queryRange(self, left: int, right: int) -> bool: l = self.data.bisect_right(left) r = self.data.bisect_right(right) if l == 0 or self.data.peekitem(l - 1)[1] < right: return False return True def removeRange(self, left: int, right: int) -> None: l = self.data.bisect_right(left) r = self.data.bisect_right(right) if l != 0: l -= 1 if self.data.peekitem(l)[1] < left: l += 1 if l != r: minLeft = min(left, self.data.peekitem(l)[0]) maxRight = max(right, self.data.peekitem(r - 1)[1]) for _ in range(l, r): self.data.popitem(l) if minLeft < left: self.data[minLeft] = left if right < maxRight: self.data[right] = maxRight
class EventsA: def __init__(self): self.events = SortedDict() def add_event(self, event): self.events[event.frame] = event def delete_event(self, index): self.events.popitem(index) def render(self, offsets, timecode): """ Return data suitable for display in LogTable :param offsets: Offsets object which contains frame offsets used to generate timecodes that match video :param timecode: Timecode object (with predefined framerate, drop_frame) used to generate timecode strings """ data = [] for event in self.events: timecode.frames = event.frame + 1 + offsets.get_offset(event.frame) data.append([event.trial, event.status, event.response, str(timecode)]) return data
def arrayRDP(arr, epsilon=0.0, n=None): """ This is a slightly modified version of the _aRDP function, that accepts as arguments the tolerance in the distance and the maximum number of points the algorithm can select. **Note:** The results of this algoritm should be identical to the arrayRDP function if the *n* parameter is not specified. In that case, the performance is slightly worse, although the asymptotic complexity is the same. For this reason, this function internally delegates the solution in that function if the *n* parameter is missing. Parameters ---------- arr: Array of values of consecutive points. epsilon: Maximum difference allowed in the simplification process. n: Maximum number of points of the resulted simplificated array. Returns ------- out: Array of indices of the selected points. """ if n is None: return _aRDP(arr, epsilon) if epsilon <= 0.0: raise ValueError('Epsilon must be > 0.0') n = n or len(arr) if n < 3: return arr fragments = SortedDict() #We store the distances as negative values due to the default order of #sorteddict dist, idx = max_vdist(arr, 0, len(arr) - 1) fragments[(-dist, idx)] = (0, len(arr) - 1) while len(fragments) < n-1: (dist, idx), (first, last) = fragments.popitem(last=False) if -dist <= epsilon: #We have to put again the last item to prevent loss fragments[(dist, idx)] = (first, last) break else: #We have to break the fragment in the selected index dist, newidx = max_vdist(arr, first, idx) fragments[(-dist, newidx)] = (first, idx) dist, newidx = max_vdist(arr, idx, last) fragments[(-dist, newidx)] = (idx, last) #Now we have to get all the indices in the keys of the fragments in order. result = SortedList(i[0] for i in fragments.itervalues()) result.add(len(arr) - 1) return np.array(result)
def compare_faces(list_of_face_encodings, unknown_face_encodings): """ Function which find 4 person which closest. """ result_list_of_faces = SortedDict() for element in list_of_face_encodings: # calculate distance from current encodings to unknown encodings current_distance = face_recognition.api.face_distance( element["face_encoding"], unknown_face_encodings) min_dist = current_distance.min() # add to our list of top matches faces if len(result_list_of_faces) < 3: result_list_of_faces.update({min_dist: element}) else: result_list_of_faces.update({min_dist: element}) result_list_of_faces.popitem() if result_list_of_faces.keys()[0] > 0.6: result_list_of_faces = None return result_list_of_faces
def top(partition_iterator, N): # create a SortedDict object, but keep the size to N sd = SortedDict() # for key, number in partition_iterator: # add an entry of (key, number) at sd sd[number] = key # always keep only Top-N items if (len(sd) > N): # remove the smallest number sd.popitem(0) ### NOTE: ### to find bottom-N, replace ### "sd.popitem(0)" with "sd.popitem(-1)" #end-for #print("local sd=", sd) # # switch key with value pairs = [(v, k) for k, v in sd.items()] #print("local top N pairs=", pairs) return pairs
def generate_first_k_a_b_sqrt2(k): nums = SortedDict() nums[0.0] = Number(0, 0) result = [] while len(result) < k: nxt = nums.popitem(0)[1] result.append(nxt.val) a = Number(nxt.a + 1, nxt.b) b = Number(nxt.a, nxt.b + 1) nums[a.val] = a nums[b.val] = b return result
def ans(n, k): m = SortedDict() m[n] = 1 bg = None while k > 0: bg, slots = m.popitem() k -= slots x, y = divide(bg) m[x] = m[x]+slots if x in m else slots m[y] = m[y]+slots if y in m else slots return ' '.join([str(x) for x in reversed(sorted(split(bg)))])
def arrayRDP(arr, epsilon=0.0, n=None): """ This is a slightly modified version of the _aRDP function, that accepts as arguments the tolerance in the distance and the maximum number of points the algorithm can select. **Note:** The results of this algoritm should be identical to the arrayRDP function if the *n* parameter is not specified. In that case, the performance is slightly worse, although the asymptotic complexity is the same. For this reason, this function internally delegates the solution in that function if the *n* parameter is missing. Parameters ---------- arr: Array of values of consecutive points. epsilon: Maximum difference allowed in the simplification process. n: Maximum number of points of the resulted simplificated array. Returns ------- out: Array of indices of the selected points. """ if n is None: return _aRDP(arr, epsilon) if epsilon <= 0.0: raise ValueError('Epsilon must be > 0.0') n = n or len(arr) if n < 3: return arr fragments = SortedDict() #We store the distances as negative values due to the default order of #sorteddict dist, idx = max_vdist(arr, 0, len(arr) - 1) fragments[(-dist, idx)] = (0, len(arr) - 1) while len(fragments) < n - 1: (dist, idx), (first, last) = fragments.popitem(last=False) if -dist <= epsilon: #We have to put again the last item to prevent loss fragments[(dist, idx)] = (first, last) break else: #We have to break the fragment in the selected index dist, newidx = max_vdist(arr, first, idx) fragments[(-dist, newidx)] = (first, idx) dist, newidx = max_vdist(arr, idx, last) fragments[(-dist, newidx)] = (idx, last) #Now we have to get all the indices in the keys of the fragments in order. result = SortedList(i[0] for i in fragments.itervalues()) result.add(len(arr) - 1) return np.array(result)
def solve(n, k): # Initial state, we have one "space" of size n m = SortedDict() m[n] = 1 bg = None while k > 0: bg, slots = m.popitem() k -= slots x, y = split(bg) m[x] = m[x] + slots if x in m else slots m[y] = m[y] + slots if y in m else slots return ' '.join([str(x) for x in reversed(sorted(split(bg)))])
def lastStoneWeight(self, stones): stones_sorted_dict = SortedDict(Counter(stones)) # print(stones_sorted_dict) while len(stones_sorted_dict) != 1: last = None while len(stones_sorted_dict) > 0: q = stones_sorted_dict.popitem() if q[1] % 2: last = q[0] if last: break if len(stones_sorted_dict) == 0: if last is None: return 0 else: return last second_last = stones_sorted_dict.peekitem()[0] stones_sorted_dict[second_last] -= 1 if stones_sorted_dict[second_last] == 0: stones_sorted_dict.popitem() q = last - second_last if q in stones_sorted_dict: stones_sorted_dict[q] += 1 else: stones_sorted_dict[q] = 1 # print(stones_sorted_dict) if len(stones_sorted_dict) == 1: if stones_sorted_dict.peekitem()[1] % 2: return stones_sorted_dict.peekitem()[0] else: return 0
def get_top_programs(logfile, n=None): sorted_programs = SortedDict() with open(logfile) as logf: for line in logf.readlines(): match = re.fullmatch('.*NPE: ([0-9]+).*Tot R: ([\.\-0-9]+)\..*Program: ([><\^\+-\[\]\.,!01234abcde]*)\n', line) if match: idx, reward, program = match.groups() idx = int(idx) reward = float(reward) sorted_programs[reward] = (idx, program) if n: for i in range(n): if not sorted_programs: break reward, (idx, program) = sorted_programs.popitem() yield reward, idx, program else: while sorted_programs: reward, (idx, program) = sorted_programs.popitem() yield reward, idx, program
class BaseNode(object): def __init__(self, tree): self.tree = tree self.bucket = SortedDict() self.changed = False def _split(self): """ Creates a new node of the same type and splits the contents of the bucket into two parts of an equal size. The lower keys are being stored in the bucket of the current node. The higher keys are being stored in the bucket of the new node. Afterwards, the new node is being returned. """ other = self.__class__(tree=self.tree) size = len(self.bucket) for i in range(int(size/2)): key, value = self.bucket.popitem() other.bucket[key] = value # print("New node created: " + str(other)) return LazyNode(node=other, tree=self.tree) def _insert(self, key, value): """ Inserts the key and value into the bucket. If the bucket has become too large, the node will be split into two nodes. """ self.bucket[key] = value self.changed = True # print(str(key)+" inserted into: " + str(self.bucket)) if len(self.bucket) > self.tree.max_size: new_node = self._split() new_node.node.changed = True return new_node pass def _get_data(self): """ Returns the encoded data of the leaf node, containing its type, and the key/value pairs. These values will eventually be the offsets of the documents. """ # print("Leaf committed: " + str(self) + " bucketsize: " + # str(len(self.bucket))) data = {"type":"Leaf", "entries":self.bucket} # print("Leaf data: "+ str(data)) return(add_integrity(encode(data)))
class BaseSimulator: def __init__(self): self.currentTime = 0.0 self.eventList = SortedDict() def addEvent(self, time, funcName, args): self.eventList[time] = [funcName, args] def deleteEvents(self, timeList): try: for key in timeList: self.eventList.pop(key) except KeyError: return def completeRun(self): try: while self.eventList.peekitem(0): self.currentTime, funcCall = self.eventList.peekitem(0) funcCall[0](funcCall[1]) self.eventList.popitem(0) except IndexError: return def run(self, timeLimit = 0): try: while self.eventList.peekitem(0): currentTime, funcCall = self.eventList.peekitem(0) if 'timeLimit' in locals(): if currentTime >= timeLimit: return funcCall[0](funcCall[1]) self.currentTime = currentTime self.eventList.popitem(0) except IndexError: return
def kWeakestRows(self, mat: List[List[int]], k: int) -> List[int]: dic = SortedDict() for idx, row in enumerate(mat): sm = sum(row) if sm in dic: dic[sm].append(idx) else: dic.setdefault(sm, [idx]) ans = [] k1 = k while k > 0: ls_curr = dic.popitem(0)[1] ans.extend(ls_curr) k -= len(ls_curr) return ans[:k1]
class Timeline: def __init__(self): self._time_cells = SortedDict() def add(self, event: Any, occurring: int): if occurring in self._time_cells: self._time_cells[occurring].append(event) else: self._time_cells[occurring] = [event] def __iter__(self): while self._time_cells: occurring, event_list = self._time_cells.popitem(0) for event in event_list: yield occurring, event
def solve(case_no): n, k = map(int, input().split()) c = SortedDict() c[n] = 1 k -= 1 while k: t, cnt = c.popitem() if (t - 1) // 2 not in c: c[(t - 1) // 2] = 0 if t // 2 not in c: c[t // 2] = 0 c[(t - 1) // 2] += min(k, cnt) c[t // 2] += min(k, cnt) if cnt <= k: k -= cnt else: c[t] = cnt - k k = 0 t = c.popitem()[0] mn, mx = (t - 1) // 2, t // 2 print("Case #{}: {} {}".format(case_no, mx, mn))
def generate_first_k_a_b_sqrt2(k): # TODO - you fill in here. candidates = SortedDict() candidates[0] = (0, 0) result = [] while candidates and len(result) < k: v, (a, b) = candidates.popitem(0) result.append(v) candidates[(a + 1) + b * 2**0.5] = a + 1, b candidates[a + (b + 1) * 2**0.5] = a, b + 1 return result
def find_closest_elements_in_sorted_arrays(sorted_arrays): diff = float('inf') tree = SortedDict() for idx, array in enumerate(sorted_arrays): i = iter(array) nxt = next(i) tree[(nxt, idx)] = i while True: min_val, min_idx = tree.peekitem(0)[0] max_val = tree.peekitem()[0][0] diff = min(diff, max_val - min_val) i = tree.popitem(0)[1] nxt = next(i, None) if nxt is None: return diff tree[(nxt, min_idx)] = i
class Events: def __init__(self): self.list_of_events = SortedDict() # for each time, a list of events def add_event(self, event): if not self.list_of_events.get(event.time): self.list_of_events[event.time] = [event] else: self.list_of_events[event.time].append(event) def count_arrivals_at(self, time): try: li = self.list_of_events[time] n = 0 for e in li: if li.type == 'arrival': n += 1 return n except: return 0 def pop_next_event(self): li = self.list_of_events.peekitem(0)[1] #if debug: # print(self.list_of_events) if (len(li) > 1): toret = li.pop(0) #if debug: # print(f'returning {toret}') return toret else: lil = self.list_of_events.popitem(0)[1] toret = lil[0] #if debug: # print(f'returning {toret}') return toret def count(self): return len(self.list_of_events) def __str__(self): s = '' for k in self.list_of_events.keys(): s += (str(k) + ": ") for e in self.list_of_events[k]: s += str(e) + ', ' return s
def runsimulation(t_max, males, F_per_M, females, female_visit_param, male_dist, bird_speed, FG_tau_mean, FG_tau_std, FG_tau_range, FG_tau_norm_range, FG_k, FG_theta, FG_divisor, RBSB_tau_mean, RBSB_tau_std, RBSB_tau_norm_range, damage_to_bower, max_maraud, n_mar, mar_ids): global birds global timeline global female_birds timeline = SortedDict() # BIRDS birds = [] female_birds = [] mars = eval(mar_ids) strategies = np.zeros(males) strategies[mars] = max_maraud # initialize positions, travel times and preferences travel_times = compute_distances_travel_times(male_dist, bird_speed) for i in range(males): birds.append( initialize_male( i, strategies[ i], #strategy for bird 0 is 0 (guarder) and 1 is max_maraud (marauder) travel_times)) # choose its first action choose_action(birds[-1], 0.0, travel_times) #initialize females for i in range(females): #females female_id = "F" + str(i) female_birds.append( initialize_female(female_id, males) ) #female IDs start where males end (if there are 10 males, the first female would be 11) #choose time for initial mating attempt first_time = female_visit_param[0] * truncnorm.rvs( female_visit_param[2], female_visit_param[3]) + female_visit_param[1] action_mating_attempt(female_id, first_time, travel_times) # this is the main loop while len(timeline) > 0: current_ticket = timeline.popitem(0) read_ticket(current_ticket[1], travel_times) return birds
class LayerDirector: verboseUnits = True def __init__(self, nClusters, nTotalUnits, Ti, Tn, NBin_nEntries, ZF): #schedule self.wakeQ = SortedDict() self.now = 0 self.ZF = ZF self.VERBOSE = op.verboseDirector self.nClusters = nClusters self.Tn = Tn # it is used when assigning filters to clusters self.nUnitsCluster = nTotalUnits / nClusters #components self.centralMem = simpleMemory.SimpleMemory(self, op.CM_size, op.CM_nPorts, op.CM_bytesCyclePort) self.clusters = [] self.coordsWindow = {} self.clustersProcWindow = {} # [windowID] -> count of clusters processing this window self.filtersPending = {} self.clustersReadingWindow = {} self.output = [] for i in range(nClusters): self.clusters.append(cluster.Cluster(self, i, self.nUnitsCluster, Ti, Tn, NBin_nEntries, op.SB_size_per_cluster, self.cbClusterDoneReading, self.cbClusterDone)) def schedule(self, entity, when = 1): when += self.now if when in self.wakeQ: self.wakeQ[when].add(entity) else: self.wakeQ[when] = set([entity]) def wakeup(self): if self.VERBOSE > 1: print "layerdirector, cycle ", self.now, len(self.wakeQ) entities = [] if len(self.wakeQ) !=0: aux, entities = self.wakeQ.popitem(False) if self.VERBOSE > 1: print "layerdirector, cycle ", self.now, aux, len(entities), " objects to wakeup" self.now = aux for obj in entities: obj.wakeup() ################################################################################## ### ### This function copy the filter weights into the unit eDRAM ### ### weights: ndarray containing the weights of the filters ### ################################################################################## def initializeLayer(self, weights): self.nTotalFilters = weights.shape[0] #how many filters have to go to each cluster nFiltersPerCluster = self.nTotalFilters / self.nClusters if self.VERBOSE: print "%d filters per cluster" % (nFiltersPerCluster) # if the total number of filters is not a multiple of nClusters nAdditionalFilters = self.nTotalFilters - (nFiltersPerCluster * self.nClusters) if self.VERBOSE: print "plus %d additional filters"%(nAdditionalFilters) # send the units the size of the filters so they can configure SB properly (simulation) for i in range(self.nClusters): self.clusters[i].initialize(weights[0].size) ##for idxFilter in range(nTotalFilters): ##self.clusters[(idxFilter / self.nClusters) % self.nClusters].fill_SB(weights[idxFilter], idxFilter) filtersAssignedSoFar = 0 idxFilter = 0 cntCluster = 0 while filtersAssignedSoFar < nFiltersPerCluster: cntFilterCluster = 0 listFilterData = [] listFilterIdxs = [] while cntFilterCluster < min(self.Tn, nFiltersPerCluster-filtersAssignedSoFar ): listFilterData.append(weights[idxFilter]) listFilterIdxs.append(idxFilter) cntFilterCluster += 1 idxFilter += 1 self.clusters[cntCluster].fill_SB(listFilterData, listFilterIdxs) cntCluster += 1 if cntCluster == self.nClusters: filtersAssignedSoFar += cntFilterCluster cntCluster = 0 #print '%d %d %d %d %d'%(nFiltersPerCluster, filtersAssignedSoFar, cntFilterCluster, self.Tn, self.nClusters) ################################################################################## # in: # data : numpy 3D ndarray of dimensions i * Wx * Wy, i=# input features, Wx=Wy= size of input # filters: a list with two elements, we will use the field "data" of both, # filters[0].data = numpy 4D ndarray of dimensions N * i * Fx * Fy with the filter values # filters[1].data = numpy 1D vector with the N biases # N = # filters, Fx=Fy= filter size ################################################################################## def computeConvolutionalLayer(self, data, filters, stride, padding, group): # TODO: when data come from modelzoo #weights = filters[0].data #biases = filters[1].data weights = filters N = weights.shape[0] i = weights.shape[1] Fx = weights.shape[2] Fy = weights.shape[3] Ix = data.shape[1] Iy = data.shape[2] if padding != 0: data = adjustDataPadding(data, padding) Ix = data.shape[1] Iy = data.shape[2] assert weights.shape[1]*group==data.shape[0], "#filters (%d) is not equal to #input features (%d)" %(weights.shape[1], data.shape[0]) assert Ix==Iy, "Input width (%d) is not equal to Input height (%d)" %(data.shape[1], data.shape[2]) assert Fx==Fy, "Filter width (%d) is not equal to Filter height (%d)" %(Fx, Fy) # initialize the layer (filters are sent to SB in the units) self.initializeLayer(weights) #### Main loop ### # Horizontal shifting for window generation self.output = np.zeros((N, (Ix-Fx)/stride+1, (Iy-Fy)/stride+1)) windowID = 0 outPosX = 0 for posInputX in range(0, Ix-Fx+1, stride): outPosY = 0 #print posInputX for posInputY in range(0, Iy-Fy+1, stride): # process each window auxWindow = data[:, posInputY:posInputY+Fy, posInputX:posInputX+Fx] self.filtersPending[windowID] = [True] * self.nTotalFilters self.initializeWindow(auxWindow, windowID) self.startWindowProcessing(auxWindow, windowID) self.coordsWindow[windowID] = [outPosX, outPosY] timeout=10000 while not self.isFinished(windowID) and timeout > 0: self.wakeup() timeout -= 1 assert timeout, "Simulation Timed Out" #output[cntFilter, outPosY, outPosX] += biases[cntFilter] windowID += 1 outPosY += 1 outPosX += 1 print "Total cycles: ", self.now def isFinished(self, windowID): #print "Pending Count = ", np.sum(self.filtersPending[windowID]) for i,e in enumerate(self.filtersPending[windowID]): if e: if self.VERBOSE > 1: print "pendingFilters for window %d"%(windowID) a = [] for j,e in enumerate(self.filtersPending[windowID]): if e: a.append(j) print a return False if self.VERBOSE > 1: print "pendingFilters for window %d LISTO"%(windowID) return True ################################################################################## ### ################################################################################## def initializeWindow(self, windowData, windowID): if self.VERBOSE: print "[director] [%d] Initializing window #%d"%(self.now, windowID) #self.windowsDataFlat[windowID] = np.swapaxes(windowData, 0, 2).flatten() self.clustersProcWindow[windowID] = self.nClusters self.clustersReadingWindow[windowID] = self.nClusters for cntCluster in range(self.nClusters): self.clusters[cntCluster].initializeWindow(windowData, windowID) ################################################################################## ### ################################################################################## def startWindowProcessing(self, windowData, windowID): if self.VERBOSE: print "[director] Processing of window #%d"%(windowID) for cntCluster in range(self.nClusters): self.schedule(self.clusters[cntCluster]) ################################################################################## ### ################################################################################## def cbClusterDoneReading(self, clusterID, windowID): self.clustersReadingWindow[windowID] -= 1 def cbClusterDone(self, clusterID, windowID): self.clustersProcWindow[windowID] -= 1 def putData(self, windowID, data, filterIDs): if self.VERBOSE > 1: print "windowID: ", windowID, " filterIDs:", filterIDs for f in filterIDs: self.filtersPending[windowID][f] = False x, y = self.coordsWindow[windowID] self.output[filterIDs, x, y] = data
sys.stdout.flush() start = time.clock() while len(upwords) < l - 2: for i in range(0,l): if i in upwords: continue for j in range(i+1,l): if j in upwords: continue dist = spatial.distance.cosine(a[i],a[j]) tempp[dist] = (i,j) if len(tempp) > limit: tempp.popitem() dicl = len(tempp) for i in range(0,dicl): tmp = tempp.popitem(last=False) if tmp[1][0] not in upwords and tmp[1][1] not in upwords: l1.append(tmp[1]) upwords.add(tmp[1][0]) upwords.add(tmp[1][1]) print 'l1len:',len(l1) sys.stdout.flush() l = len(l1) upwords = set() while len(upwords) < l - 2: for i in range(0,l):
def test_popitem2(): temp = SortedDict() temp.popitem()
def test_popitem(): mapping = [(val, pos) for pos, val in enumerate(string.ascii_lowercase)] temp = SortedDict(mapping) assert temp.popitem() == ('z', 25)
def test_popitem2(): temp = SortedDict() with pytest.raises(KeyError): temp.popitem()
# http://www.grantjenks.com/docs/sortedcontainers/ from sortedcontainers import SortedList sl = SortedList(['e', 'a', 'c', 'd', 'b']) print(sl) sl *= 10000000 print(sl.count('c')) print(sl[-3:]) ['e', 'e', 'e'] from sortedcontainers import SortedDict sd = SortedDict({'c': 3, 'a': 1, 'b': 2}) print(sd) SortedDict({'a': 1, 'b': 2, 'c': 3}) print(sd.popitem()) from sortedcontainers import SortedSet ss = SortedSet('abracadabra') print(ss) print(ss.bisect_left('c'))
class StreamChangeCache(object): """Keeps track of the stream positions of the latest change in a set of entities. Typically the entity will be a room or user id. Given a list of entities and a stream position, it will give a subset of entities that may have changed since that position. If position key is too old then the cache will simply return all given entities. """ def __init__(self, name, current_stream_pos, max_size=10000, prefilled_cache=None): self._max_size = int(max_size * caches.CACHE_SIZE_FACTOR) self._entity_to_key = {} self._cache = SortedDict() self._earliest_known_stream_pos = current_stream_pos self.name = name self.metrics = caches.register_cache("cache", self.name, self._cache) if prefilled_cache: for entity, stream_pos in prefilled_cache.items(): self.entity_has_changed(entity, stream_pos) def has_entity_changed(self, entity, stream_pos): """Returns True if the entity may have been updated since stream_pos """ assert type(stream_pos) in integer_types if stream_pos < self._earliest_known_stream_pos: self.metrics.inc_misses() return True latest_entity_change_pos = self._entity_to_key.get(entity, None) if latest_entity_change_pos is None: self.metrics.inc_hits() return False if stream_pos < latest_entity_change_pos: self.metrics.inc_misses() return True self.metrics.inc_hits() return False def get_entities_changed(self, entities, stream_pos): """ Returns subset of entities that have had new things since the given position. Entities unknown to the cache will be returned. If the position is too old it will just return the given list. """ assert type(stream_pos) is int if stream_pos >= self._earliest_known_stream_pos: changed_entities = { self._cache[k] for k in self._cache.islice( start=self._cache.bisect_right(stream_pos), ) } result = changed_entities.intersection(entities) self.metrics.inc_hits() else: result = set(entities) self.metrics.inc_misses() return result def has_any_entity_changed(self, stream_pos): """Returns if any entity has changed """ assert type(stream_pos) is int if not self._cache: # If we have no cache, nothing can have changed. return False if stream_pos >= self._earliest_known_stream_pos: self.metrics.inc_hits() return self._cache.bisect_right(stream_pos) < len(self._cache) else: self.metrics.inc_misses() return True def get_all_entities_changed(self, stream_pos): """Returns all entites that have had new things since the given position. If the position is too old it will return None. """ assert type(stream_pos) is int if stream_pos >= self._earliest_known_stream_pos: return [self._cache[k] for k in self._cache.islice( start=self._cache.bisect_right(stream_pos))] else: return None def entity_has_changed(self, entity, stream_pos): """Informs the cache that the entity has been changed at the given position. """ assert type(stream_pos) is int if stream_pos > self._earliest_known_stream_pos: old_pos = self._entity_to_key.get(entity, None) if old_pos is not None: stream_pos = max(stream_pos, old_pos) self._cache.pop(old_pos, None) self._cache[stream_pos] = entity self._entity_to_key[entity] = stream_pos while len(self._cache) > self._max_size: k, r = self._cache.popitem(0) self._earliest_known_stream_pos = max( k, self._earliest_known_stream_pos, ) self._entity_to_key.pop(r, None) def get_max_pos_of_last_change(self, entity): """Returns an upper bound of the stream id of the last change to an entity. """ return self._entity_to_key.get(entity, self._earliest_known_stream_pos)