def test_node_repr(self): a = dllist([None]).first self.assertEqual(repr(a), "<dllistnode(None)>") b = dllist([1, None]).first self.assertEqual(repr(b), "<dllistnode(1)>") c = dllist(["abc", None]).first self.assertEqual(repr(c), "<dllistnode('abc')>")
def test_node_repr(self): a = dllist([None]).first self.assertEqual(repr(a), '<dllistnode(None)>') b = dllist([1, None]).first self.assertEqual(repr(b), '<dllistnode(1)>') c = dllist(['abc', None]).first self.assertEqual(repr(c), '<dllistnode(\'abc\')>')
def test_node_str(self): a = dllist([None, None]).first self.assertEqual(str(a), "dllistnode(None)") b = dllist([1, None]).first self.assertEqual(str(b), "dllistnode(1)") c = dllist(["abc", None]).first self.assertEqual(str(c), "dllistnode(abc)")
def test_node_str(self): a = dllist([None, None]).first self.assertEqual(str(a), 'dllistnode(None)') b = dllist([1, None]).first self.assertEqual(str(b), 'dllistnode(1)') c = dllist(['abc', None]).first self.assertEqual(str(c), 'dllistnode(abc)')
def __init__(self, input_text: str): # Regular expressions delimiter_pattern = r'[,:;-]' delimiter_regex = re.compile(delimiter_pattern) # Create data structures self.data = dllist() self.delimiters = dllist() # Break apart by sentence sentences = sent_tokenize(input_text) for sentence in sentences: # Add a new linked list for the sentence and delimiters cur_delimiters = dllist() cur_sentence = dllist() # Split by whitespace t_sentence = sentence.split() [cur_sentence.append(word) for word in t_sentence] [ cur_delimiters.append( [index, delimiter_regex.search(word).group(0)]) for index, word in enumerate(t_sentence) if delimiter_regex.search(word) ] # Add it in self.delimiters.append(cur_delimiters) self.data.append(cur_sentence)
def test_guards_after_concat(self): a = dllist([1, 2]) b = dllist([3, 4]) c = a + b self.assertIsNot(c.first, None) self.assertEqual(c.first.value, 1) self.assertIsNot(c.last, None) self.assertEqual(c.last.value, 4)
def test_guards_after_concat_inplace(self): a = dllist([1, 2]) b = dllist([3, 4]) orig_a_first = a.first a += b self.assertIs(a.first, orig_a_first) self.assertEqual(a.first.value, 1) self.assertIsNot(a.last, None) self.assertEqual(a.last.value, 4)
def test_concat(self): a_ref = range(0, 1024, 4) a = dllist(a_ref) b_ref = range(8092, 8092 + 1024, 4) b = dllist(b_ref) ab_ref = dllist(a_ref + b_ref) c = a + b self.assertEqual(c, ab_ref) self.assertEqual(len(c), len(ab_ref)) c = a + b_ref self.assertEqual(c, ab_ref) self.assertEqual(len(c), len(ab_ref))
def test_cmp(self): a = dllist(xrange(0, 1100)) b = dllist(xrange(0, 1101)) c = range(0, 1100) self.assertEqual(cmp(a, a), 0) self.assertEqual(cmp(a, b), -1) self.assertEqual(cmp(b, a), 1) self.assertEqual(cmp(a, c), 0) self.assertEqual(cmp(c, a), 0) self.assertEqual(cmp([], []), 0) self.assertEqual(cmp([], a), -1) self.assertEqual(cmp(a, []), 1)
def test_cmp(self): a = dllist(xrange(0, 1100)) b = dllist(xrange(0, 1101)) c = [xrange(0, 1100)] self.assertEqual(cmp(a, a), 0) self.assertEqual(cmp(a, b), -1) self.assertEqual(cmp(b, a), 1) self.assertEqual(cmp(a, c), 1) self.assertEqual(cmp(c, a), -1) self.assertEqual(cmp([], []), 0) self.assertEqual(cmp([], a), -1) self.assertEqual(cmp(a, []), 1)
def heavy_hitters(e): k = int(1.0 / e - 1) table = {} inner = dllist() for i in range(k): inner.insert([None, 0]) outer = dllist([inner]) min_count = 0 with open("Data.txt") as data: for line in data: print line if not table.has_key(line): if outer.first.value.first.value[1] == min_count: victim = outer.first.value.popleft() if table.has_key(victim[0]) : table.pop(victim[0], None) outer.first.value.insert([line, min_count]) table[line] = [outer.first, outer.first.value.last] if table.has_key(line): a = table.get(line) a[1].value[1] += 1 if a[0].next: if a[0].next.value.first.value[1] == a[1].value[1]: tl = a[0].next tn = a[0].value.remove(a[1]) tl.value.appendleft(tn) table[line] = [tl, tl.value.first] if a[0].value.size == 0: outer.remove(a[0]) else: tn = a[0].value.remove(a[1]) new_inner = dllist() new_inner.appendleft(tn) outer.insert(new_inner, after=a[0]) table[line] = [a[0].next, a[0].next.value.first] if a[0].value.size == 0: outer.remove(a[0]) else: tn = a[0].value.remove(a[1]) new_inner = dllist() new_inner.appendleft(tn) outer.insert(new_inner, after=a[0]) table[line] = [a[0].next, a[0].next.value.first] if a[0].value.size == 0: outer.remove(a[0]) else: min_count += 1 return table
def test_appendleft(self): ll = dllist(xrange(4)) ref = dllist([10, 0, 1, 2, 3]) next = ll.nodeat(0) arg_node = dllistnode(10) new_node = ll.appendleft(arg_node) self.assertNotEqual(new_node, arg_node) self.assertEqual(new_node.value, 10) self.assertEqual(new_node.prev, None) self.assertEqual(new_node.next, next) self.assertEqual(next.prev, new_node) self.assertEqual(ll.first, new_node) self.assertEqual(ll, ref)
def test_appendright(self): ll = dllist(xrange(4)) ref = dllist([0, 1, 2, 3, 10]) prev = ll.nodeat(-1) arg_node = dllistnode(10) new_node = ll.appendright(arg_node) self.assertNotEqual(new_node, arg_node) self.assertEqual(new_node.value, 10) self.assertEqual(new_node.prev, prev) self.assertEqual(new_node.next, None) self.assertEqual(prev.next, new_node) self.assertEqual(ll.last, new_node) self.assertEqual(ll, ref)
def test_insert_value_after_last(self): ll = dllist(xrange(4)) ref = dllist([0, 1, 2, 3, 10]) prev = ll.nodeat(3) arg_node = dllistnode(10) new_node = ll.insert(arg_node, after=ll.last) self.assertNotEqual(new_node, arg_node) self.assertEqual(new_node.value, 10) self.assertEqual(new_node.prev, prev) self.assertEqual(new_node.next, None) self.assertEqual(prev.next, new_node) self.assertEqual(new_node, ll.last) self.assertEqual(ll, ref)
def test_concat_empty(self): empty = dllist() filled_ref = range(0, 1024, 4) filled = dllist(filled_ref) res = empty + empty self.assertEqual(res, dllist([] + [])) self.assertEqual(len(res), 0) res = empty + filled self.assertEqual(res, dllist([] + filled_ref)) self.assertEqual(len(res), len(filled_ref)) res = filled + empty self.assertEqual(res, dllist(filled_ref + [])) self.assertEqual(len(res), len(filled_ref))
def test_insert_value_after(self): ll = dllist(xrange(4)) ref = dllist([0, 1, 10, 2, 3]) prev = ll.nodeat(1) next = ll.nodeat(2) arg_node = dllistnode(10) new_node = ll.insert(arg_node, after=ll.nodeat(1)) self.assertNotEqual(new_node, arg_node) self.assertEqual(new_node.value, 10) self.assertEqual(new_node.prev, prev) self.assertEqual(new_node.next, next) self.assertEqual(prev.next, new_node) self.assertEqual(next.prev, new_node) self.assertEqual(ll, ref)
def test_node_after_del(self): ll = dllist([1, 2, 3]) node = ll.nodeat(1) del ll[1] self.assertIs(node.prev, None) self.assertIs(node.next, None) self.assertIs(node.list, None)
def convertPattern(pattern, bpm): spt = secondsPerTick(bpm, pattern.resolution) notestore = dllist() def addnotestore(notedata): if notedata[2] == False: for noteidx in xrange(len(notestore)): if notestore[noteidx][2] == True and notestore[noteidx][ 1] == notedata[1]: note = notestore[noteidx] del notestore[noteidx] yield (note[0] * spt, notedata[0] * spt, note[1]) break else: print("Starting match not found for ", notedata) else: notestore.append(notedata) for track in pattern: for event in track: if isinstance(event, midi.events.NoteOnEvent): if event.data[1] == 0: for x in addnotestore((event.tick, event.data[0], False)): yield x else: for x in addnotestore((event.tick, event.data[0], True)): yield x elif isinstance(event, midi.events.NoteOffEvent): for x in addnotestore((event.tick, event.data[0], False)): yield x
def test_guards_after_remove(self): ll = dllist([1, 2]) ll.remove(ll.last) self.assertIs(ll.first, ll.last) ll.remove(ll.first) self.assertIs(ll.first, None) self.assertIs(ll.last, None)
def __init__(self, id, model_type="TDD"): self.id = id self.site_list = dllist() if (model_type == "TDD"): self.energy_model = TddRtuModel.TddRtuModel() else: self.energy_model = None self.site_count = 0 self.asset_count = 0 self.x_tons = 0 self.x_evap_hp = 0 self.x_avg_age = 0 self.x_avg_weighted_age = 0 self.x_avg_eer = 0 self.x_avg_weighted_eer = 0 self.n_tons = 0 self.n_evap_hp = 0 self.n_avg_age = 0 self.n_avg_weighted_age = 0 self.n_avg_eer = 0 self.n_avg_weighted_eer = 0 self.pre_kwh_hvac_yearly = 0 self.post_kwh_hvac_yearly = 0 self.sav_kwh_hvac_yearly = 0 self.pre_therms_hvac_yearly = 0 self.post_therms_hvac_yearly = 0 self.sav_therms_hvac_yearly = 0 self.kwh_hvac_reduction_pct = 0 self.ecm_manager = EcmManager.EcmManager() self.hourly_data_manager = HourlyDataManager.HourlyDataManager() self.update_input_file_flag = False
def test_node_after_remove(self): ll = dllist([1, 2, 3]) node = ll.nodeat(1) ll.remove(node) self.assertIs(node.prev, None) self.assertIs(node.next, None) self.assertIs(node.list, None)
def test_init_empty(self): ll = dllist() self.assertEqual(len(ll), 0) self.assertEqual(ll.size, 0) self.assertEqual(list(ll), []) self.assertIs(ll.first, None) self.assertIs(ll.last, None)
def __init__(self, **kwargs): super().__init__() self._tslam = kwargs['tslam'] self._paranoia = 0 # Argument parsing ---------------------------------------------------- {{{ argp = argparse.ArgumentParser() self._init_add_args(argp) self._init_handle_args(argp.parse_args(kwargs['cliargs'])) # --------------------------------------------------------------------- }}} self._pagelog = 12 self._basepg = 1 baseva = self._basepg * 2**self._pagelog self._brscache = None self._eva2sst = IntervalMap(baseva, 2**64 - baseva, SegSt.AHWM) self._eva2sz = {} self._evp2pst = IntervalMap(self._basepg, 2**(64 - self._pagelog) - self._basepg, PageSt.UMAP) self._junklru = dllist() self._junkadn = {} self._njunk = 0 self._nmapped = 0 self._npend = 0 self._nwait = 0 self._tidylst = SegFreeList(extcoal=self._sfl_coalesce) self._wildern = baseva
def __init__(self, **kwargs): super().__init__() self._tslam = kwargs['tslam'] # Argument parsing ---------------------------------------------------- {{{ argp = argparse.ArgumentParser() self._init_add_args(argp) self._init_handle_args(argp.parse_args(kwargs['cliargs'])) # --------------------------------------------------------------------- }}} # Power of two, greater than page log self._bucklog = 16 self._pagelog = 12 self._maxbix = 1 # Next never-touched bucket index (AHWM) self._szbix2ap = {} # BUMP allocation pointer by size and bix self._bix2szbm = {} # BUMP and WAIT buckets' size and bitmaps self._njunkb = 0 # Number of buckets in JUNK state self._nbwb = 0 # Number of buckets in BUMP|WAIT states self._bix2state = IntervalMap(self._maxbix, 2**(64 - self._bucklog) - self._maxbix, BuckSt.AHWM) self._brscache = None # Biggest revokable span cache self._junklru = dllist() # List of all revokable spans, LRU self._junkbdn = {} # JUNK bix to node in above list
def pref_update_callback(self, event): # copy to lower the chance of chaning size state_oppo_neigh_temp = {k:v for k, v in self.state_oppo_neigh.items()} cand_dict = {p: self.get_efficiency(state.x, self.vmax, state.speed)\ for p, state in state_oppo_neigh_temp.items()} cand_sort = dllist([[k, v] for k, v in sorted(cand_dict.items(), key=lambda x: x[1])]) pin = 0 if cand_sort.size <= self.ub else int(-self.ub) pref = [n.value[0] for n in cand_sort.nodeat(pin).iternext()] if cand_sort.size > 0 else [] _n = len(pref) for i in pref[::-1]: # print(str(self), 'before check neigbour', i, pref) for d, state in self.state_team_neigh.items(): if i in state.pref and cand_dict[i] < state.pref[i]: # print(str(self), 'before check neigbour', i, pref) pref.remove(i) break; # nremoved += 1 n_ = len(pref) for k in range(_n - n_): if cand_sort.nodeat(pin).prev is None: break pref = [cand_sort.nodeat(pin).prev.value[0]] + pref pin -= 1 pref_dict = {p: cand_dict[p] for p in pref[::-1]} self.state.pref = pref_dict self.pref_pub.publish('_'.join(list(map(str, [p + '=%.6f'%e for p, e in pref_dict.items()]))))
def test_guards_after_appendright(self): ll = dllist() node1 = ll.appendright(1) self.assertIs(ll.first, node1) self.assertIs(ll.last, node1) node2 = ll.appendright(2) self.assertIs(ll.first, node1) self.assertIs(ll.last, node2)
def test_guards_after_repeat_inplace(self): ll = dllist([1, 2]) orig_first = ll.first orig_last = ll.last ll *= 4 self.assertIs(ll.first, orig_first) self.assertIsNot(ll.last, None) self.assertIsNot(ll.last, orig_last)
def test_guards_after_popright(self): ll = dllist([1, 2]) ll.pop() self.assertIs(ll.first, ll.last) self.assertEqual(ll.first.value, 1) ll.pop() self.assertIs(ll.first, None) self.assertIs(ll.last, None)
def test_guards_after_insert(self): ll = dllist() node1 = ll.insert(dllistnode(1)) self.assertIs(ll.first, node1) self.assertIs(ll.last, node1) node2 = ll.insert(dllistnode(2)) self.assertIs(ll.first, node1) self.assertIs(ll.last, node2)
def test_guards_after_del(self): ll = dllist([1, 2]) orig_last = ll.last del ll[0] self.assertIs(ll.first, orig_last) self.assertIs(ll.last, orig_last) del ll[0] self.assertIs(ll.first, None) self.assertIs(ll.last, None)
def test_popright(self): ref = range(0, 1024, 4) ll = dllist(ref) result = ll.popright() self.assertEqual(result, ref[-1]) self.assertEqual(len(ll), len(ref) - 1) self.assertEqual(ll.size, len(ref) - 1) self.assertEqual(ll.last.value, ref[-2]) self.assertEqual(list(ll), ref[:-1])
def test_iternodes(self): ref = range(0, 1024, 4) ll = dllist(ref) idx = 0 for node in ll.iternodes(): self.assertTrue(isinstance(node, dllistnode)) self.assertEqual(node.value, ref[idx]) idx += 1 self.assertEqual(idx, len(ref))
def test_reversed(self): ref = range(0, 1024, 4) ll = dllist(ref) idx = len(ref) - 1 for val in reversed(ll): self.assertFalse(isinstance(val, dllistnode)) self.assertEqual(val, ref[idx]) idx -= 1 self.assertEqual(idx, -1)
def test_iternext(self): ref = range(0, 1024, 4) ll = dllist(ref) idx = 100 for node in ll.nodeat(idx).iternext(): self.assertTrue(isinstance(node, dllistnode)) self.assertEqual(node.value, ref[idx]) idx += 1 self.assertEqual(idx, len(ref))
def test_popleft(self): ref = range(0, 1024, 4) ll = dllist(ref) result = ll.popleft() self.assertEqual(result, ref[0]) self.assertEqual(len(ll), len(ref) - 1) self.assertEqual(ll.size, len(ref) - 1) self.assertEqual(ll.first.value, ref[1]) self.assertEqual(list(ll), ref[1:])
def test_iter(self): ref = range(0, 1024, 4) ll = dllist(ref) idx = 0 for val in ll: self.assertFalse(isinstance(val, dllistnode)) self.assertEqual(val, ref[idx]) idx += 1 self.assertEqual(idx, len(ref))
def test_init_with_sequence(self): ref = range(0, 1024, 4) ll = dllist(ref) self.assertEqual(len(ll), len(ref)) self.assertEqual(ll.size, len(ref)) self.assertEqual(list(ll), ref) self.assertIsNot(ll.first, None) self.assertEqual(ll.first.value, 0) self.assertIsNot(ll.last, None) self.assertEqual(ll.last.value, 1020)
def test_guards_after_concat_inplace_of_self(self): ll = dllist([1, 2]) orig_first = ll.first orig_last = ll.last ll += ll self.assertIs(ll.first, orig_first) self.assertEqual(ll.first.value, 1) self.assertIsNot(ll.last, None) self.assertIsNot(ll.last, orig_last) self.assertEqual(ll.last.value, 2)