def __init__(self):
""" Constructor """
#
self.by_time = rbtree()
self.by_id = rbtree()
self.by_time_cache = None
# We change this flag after adding or removing event
self.changed = False
def test_cmp(self):
reverse = lambda x, y: cmp(x, y) * -1
r = rbtree(dict(zip(range(10), range(10))), cmp=reverse)
assert r.keys() == list(reversed(range(10)))
badcmp = lambda x, y: 'z'
try:
r = rbtree(dict(zip(range(10), range(10))), cmp=badcmp)
except TypeError:
pass
else:
raise TypeError("Allowed Cmp that returns string?")
def test_pop(self):
r = rbtree(dict(zip(range(10), range(1, 11))))
assert len(r) == 10
# Pops the values, not the keys
assert r.pop() == 1
assert r.pop() == 2
assert len(r) == 8
def test_replace(self):
r = rbtree()
r[1] = 2
assert r[1] == 2
r[1] = 3
assert r[1] == 3
assert len(r) == 1
def find_top_k_with_rbtree(filename = TDATA, k = 10):
"""
Profile result:
5 million strings:
memory consuming: 259 MB
time consuming: 92.625
[(753, 'bf'),
(753, 'qj'),
(753, 'zb'),
(753, 'vz'),
(763, 'ma'),
(755, 'lx'),
(779, 'qp'),
(768, 'bg'),
(758, 'eq'),
(767, 'tf')]
"""
result = []
t = rbtree.rbtree()
with open(filename) as f:
for line in f:
key = line.strip()
t[key] = t.setdefault(key, 0) + 1
# heapq
for key, val in t.iteritems():
if len(result) < k:
heapq.heappush(result, (val, key))
else:
heapq.heappushpop(result, (val, key))
return result
def test_clear(self):
r = rbtree(dict(zip(range(10), range(1, 11))))
assert 5 in r
r.clear()
assert len(r) == 0
assert 5 not in r
r = r.update(dict(zip(range(10), range(1, 11))))
def test_offset(self):
r = rbtree(dict(zip(range(10), range(10))))
# get keys by offset
assert r.byOffset(2) == 2
assert r.byOffset(1) == 1
assert r.byOffset(0) == 0
assert r.byOffset(-1) == 9
assert r.byOffset(-2) == 8
def test_copy(self):
r = rbtree(dict(zip(range(10), range(1, 11))))
c = r.copy()
assert 5 in r
assert 5 in c
del r[5]
assert 5 not in r
assert 5 in c
def test_itermode(self):
r = rbtree([(chr(i), True) for i in range(ord('a'), ord('z') + 1)])
it = r.iternodes()
for n in it:
n.get(KEYS)
n.get(VALUES)
n.get(ITEMS)
n.get(NODES)
def test_pickle(self):
import pickle
r = rbtree([(chr(i), True) for i in range(ord('a'), ord('z') + 1)])
s = pickle.dumps(r, protocol=-1)
t = pickle.loads(s)
assert t.keys() == [chr(i) for i in range(ord('a'), ord('z') + 1)]
# and with a custom cmp function, this has to be module global
# to work because of pickle
global ncmp
def ncmp(a, b):
return cmp(a.lower(), b.lower())
r = rbtree({'a': 1, 'A': 2}, ncmp)
s = pickle.dumps(r, protocol=-1)
t = pickle.loads(s)
assert t == r
def test_missing(self):
r = rbtree({'a': 'b'})
assert r['a']
try:
print r['missing']
except KeyError:
pass
else:
raise KeyError("Able to find missing key")
def test_slicing(self):
r = self.sample_data()
# This should return all matches between b and c in the wordlist
slice = r['b':'c']
assert len(slice)
assert slice.keys()
del slice
# Empty slices return empty trees
r = rbtree()
assert len(r[0:100]) == 0
def test_random_insert(self):
import random
r = rbtree()
nums = range(1000)
random.shuffle(nums)
for i in nums:
r[i] = True
assert r.keys() == range(1000)
assert r[800:810].keys() == range(800, 810)
def __init__(self, size, confidence, epsilon, beta):
super(UCB, self).__init__()
self.n = size
self.confidence = confidence
self.epsilon = epsilon
self.beta = beta
self.ucb_node = []
for i in range(0, size, 1):
self.ucb_node.append(UCBNode(0, i))
self.ucb = rbtree.rbtree()
def bentley_ottman(lines): cur_tree = rbtree(cmp=fail_py.cmp) mylines = list() invalid = dict() for l in lines: if l[0] > l[1]: l0, l1 = l[1], l[0] else: l0, l1 = l[0], l[1] g = (l1[0] - l0[0], l1[1] - l1[0]) o = l0[1] - l0[0] * g[1] mylines.append((l0, l1, g, o)) endpoints = sum([[(l[0],2,l), (l[1],0,l)] for l in mylines],[]) heapq.heapify(endpoints) queue = endpoints while True: try: event = heapq.heappop(queue) except IndexError, e: break if event in invalid: continue fail_py.L = event[0] if event[1] == 2: # Start; addit cur_tree[event[2]] = None p = get_prev(cur_tree,event[2]) n = get_next(cur_tree,event[2]) rem_cross(queue,p,n) add_cross(queue,p,event[2]) add_cross(queue,event[2],n) elif event[1] == 0: # End; killit del cur_tree[event[2]] p = get_prev(cur_tree,event[2]) n = get_next(cur_tree,event[2]) rem_cross(queue,p,event[2]) rem_cross(queue,event[2],n) add_cross(queue,p,n) elif event[2] == 1: # Crossing; swap and add crossings.append(event[0]) p = get_prev(cur_tree,event[2]) n = get_next(cur_tree,event[3]) rem_cross(queue,p,event[2]) rem_cross(queue,event[3],n) # Sort order ensures we now swap. del cur_tree[event[2]] cur_tree[event[2]] = None add_cross(queue,p,event[3]) add_cross(queue,event[2],n)
def test_iterdirection(self):
r = rbtree(dict(zip(range(10), range(10))))
i = iter(r)
assert i.next() == 0
assert i.next() == 1
assert i.next() == 2
i.direction = -1
assert i.next() == 1
assert i.next() == 0
i = iter(r)
i.direction = -1
assert i.next() == 9
def __init__(self, G, s):
self.dist = dict(map(lambda a: (a, float("inf")), G.nodes()))
self.dist[s] = 0.0
self.edge = dict()
self.G = G
# relax vertices in order of distance from s
self.pq = rbtree.rbtree()
self.pq[(self.dist[s], s)] = s
while len(self.pq) > 0:
v = self.pq.pop()
for e in G.adj(v):
self._relax(v, e)
def __init__(self, kappa, th, sigma, DecryptFile, ss):
"""
Make a segment tree.
A node in this tree is a 3-list: [leftson, rightson, NumberOfuf]
This tree at most has self.kappa layers
"""
self.root = [None, None, 0]
self.Dedup = rbtree.rbtree(lambda x:int(x[1], 2)) #a value in Dedup is (hv1, hv2, F0_name)
self.kappa = kappa
self.FILTRATION = 2 ** kappa - 1
self.DecryptFile = DecryptFile #(hv1, hv2, ufname)
self.th = th
self.sigma = sigma
self.ss = ss
self.DecFileNum = 0
def test_iterprev(self):
r = rbtree([(chr(i), True) for i in range(ord('a'), ord('z') + 1)])
i = r.iternodes()
i.goto('c')
assert i.key == 'c'
i.prev()
assert i.key == 'b'
i.next()
assert i.key == 'c'
# Now we flip the base direction
i.direction = -1
i.next()
assert i.key == 'b'
i.prev()
assert i.key == 'c'
def __init__(self, parent):
self._bulk_set = []
self._cache = rbtree()
self._parent = parent
if isinstance(parent, StaticMemory):
self._heap_next = 0x00007ffff7f93000 #0x80000000
self._heap_blocks = dict()
self._heap_free = dict()
else:
self._heap_next = parent._heap_next
self._heap_blocks = dict(parent._heap_blocks)
self._heap_free = dict(parent._heap_free)
if self.depth() > 8:
self.flatten()
def test_multikey_compare(self):
# use a cmp function that allows for key matches
def multicmp(x, y):
x = cmp(x, y)
if x == 0: return 1
return x
r = rbtree(cmp=multicmp)
r[1] = 2
r[1] = 3
assert len(r) == 2
assert 2 in r.values()
assert 3 in r.values()
i = iter(r)
i.next()
i.delete()
assert len(r) == 1
def __init__(self, netIn, netOut, pFail, sharedStat, id, x, y):
self.inBuf = PQueue()
self.outBuf = FQueue()
self.isWorking = True
#self.delayRoll = [0] * self.DELAY_SLOT_NUM
self.msgPeerDict = rbtree.rbtree()
#self.delMsgSet = rbtree.rbtree()
self.netIn = netIn
self.netOut = netOut
self.pFail = pFail
self.userNodes = sharedStat['userNodes']
self.timer = sharedStat['timer']
#self.msgCount = MsgCounter(self.timer)
self.id = id
self.x = x
self.y = y
def test_stopiteration(self):
r = rbtree({'a': 'b', 'c': 'd'})
i = iter(r)
# iterate the whole set
list(i)
# now each call should raise StopIteration to complie with the
# protocol
try:
i.next()
except StopIteration:
pass
else:
raise NotImplementedError()
try:
i.next()
except StopIteration:
pass
else:
raise NotImplementedError()
def test_itergoto(self):
r = rbtree(dict(zip(range(10), range(10))))
i = iter(r)
i.goto(5)
assert i.next() == 6
assert i.next() == 7
# Just to key 5 and walk backwards getting the items tuple
i2 = r.iteritems()
i2.goto(5)
i2.direction = -1
assert i2.next() == (4, 4)
# Now goto a missing key
try:
i2.goto('missing')
except KeyError:
pass
else:
raise KeyError("Found Missing key in iter")
def saveStat(self, project, name, time, value):
self.store.setdefault(project, {})
if name not in self.store[project]:
self.store[project][name] = rbtree.rbtree()
self.store[project][name][time] = value
def test_slice_partial(self):
r = rbtree(dict(zip(range(10), range(10))))
assert r[8:]
def test_iter_refcount(self):
r = rbtree(dict(zip(range(10), range(1, 11))))
i = iter(r)
del r
assert list(i) == range(10)
def __init__(self): self.map = rbtree.rbtree()
def test_slicing_stepping(self):
r = rbtree(dict(zip(range(10), range(10))))
assert r[0:8:2].keys() == [0, 2, 4, 6]
assert r[1:8:3].keys() == [1, 4, 7]
# neg slice stride makes no sense with cmp ordered keys
assert r[0:8:-2].keys() == [0, 2, 4, 6]
def test_create(self):
r = rbtree()
assert len(r) == 0
def test_axes(self):
r = rbtree(dict(zip(range(10), range(1, 11))))
assert r.keys() == range(10)
assert r.values() == range(1, 11)
assert r.items() == zip(range(10), range(1, 11))
def test_create_sequence(self):
r = rbtree((('a', 'b'), ('c', 'd')))
assert len(r) == 2
assert r['a'] == 'b'
assert r['c'] == 'd'
def __init__(self, trade_callback=print):
self.trade_callback = trade_callback
self.asks = rbtree()
# reverse comparator
self.bids = rbtree(cmp=lambda x,y: y-x)
def test_delslice(self):
r = rbtree([(chr(i), True) for i in range(ord('a'), ord('z') + 1)])
del r['a':'x']
assert r.keys() == ['x', 'y', 'z']
del r['y':]
assert r.keys() == ['x']
def test_slice_endcase(self):
r = rbtree((('x', 1), ('y', 1), ('z', 1)))
assert r['y':].keys() == ['y', 'z']
def test_dict(self):
r = rbtree({'a': 'b'})
d = dict(r)
assert d['a'] == 'b'
def main():
r = rbt.rbtree()
print "hello: "
def test_create_mapping(self):
r = rbtree({'a': 'b'})
assert len(r) == 1
assert r['a'] == 'b'
import rbtree
class Post:
def __init__(self):
self.time = 1
def __cmp__(self, other):
print 'called'
return self.time < other.time
def __str__(self):
return 'ptime ' + str(self.time)
r = rbtree.rbtree()
p1 = Post()
p1.time += 1
p2 = Post()
p3 = Post()
r[p1] = p1
r[p2] = p2
print '-----------'
for x in r:
if x >= p1:
print x
def __init__(self, timer):
self.timer = timer
self.msgQueue = rbtree.rbtree()
