def _create_skiplist(self, n):
# Create a skiplist with *n* elements.
sl = SkipList()
maxkey = 100 * n
for i in range(n):
sl.insert(random.randint(0, maxkey), i)
return sl
def test_size(self):
sl = SkipList()
sl.insert('foo', 'bar')
size = getsize(sl)
self.assertIsInstance(size, int)
self.assertGreater(size, 0)
self.assertLess(size, 5000)
def __init__(self,
size,
n_partitions,
priority_func,
alpha,
beta_schedule,
min_experiences=None,
name=None):
self.size = size
self.n_partitions = n_partitions
self.priority_func = priority_func
self.alpha = alpha
self.beta_schedule = beta_schedule
self.min_experiences = min_experiences
self.index = 0
self._experiences = {}
# Note this is actually a MIN priority queue, so to make it act like a MAX priority
# queue, we use the negative of the provided priorities.
self.skip_list = SkipList()
self.distributions = self.build_distribution()
self._active_set = None
super(PrioritizedReplayBuffer, self).__init__(name)
def test_node_size(self):
sl = SkipList()
for i in range(1000):
sl.insert(i, None)
size = getsize(sl)
self.assertIsInstance(size, int)
self.assertGreater(size, 0)
self.assertLess(size / 1000, 250)
def mem_node_size(self):
for logN in range(3, 6):
items = 10**logN
sl = SkipList()
for i in range(items):
sl.insert(i, i)
size = getsize(sl)
self.add_result(size / items, suffix=items)
def mem_node_overhead(self):
for logN in range(3, 6):
items = 10**logN
sl = SkipList()
for i in range(items):
sl.insert(i, i)
overhead = getsize(sl) - items * 2 * sys.getsizeof(i)
self.add_result(overhead / items, suffix=items)
def test_dump(self):
sl = SkipList()
sl.insert('foo', 'bar')
sl.insert('baz', 'qux')
out = six.StringIO()
dump(sl, out)
s = out.getvalue()
self.assertIsInstance(s, str)
self.assertGreater(len(s), 20)
def test_bool(self):
sl = SkipList()
self.assertFalse(sl)
self.assertFalse(bool(sl))
check(sl)
sl.insert('foo', 'bar')
self.assertTrue(sl)
self.assertTrue(bool(sl))
check(sl)
def insert(self, index, value):
index = int(index)
new = SkipList()
for k, v in self.data.items(stop=index):
new.insert(k, v)
new.insert(index, value)
for k, v in self.data.items(start=index):
new.insert(k + 1, v)
self.data = new
def test_len(self):
size = self.size
sl = SkipList()
pairs = []
for i in range(size):
pair = (random.randint(0, 2 * size), random.randint(0, 10 * size))
sl.insert(*pair)
pairs = sorted(pairs + [pair], key=lambda x: x[0])
self.assertEqual(len(sl), i + 1)
check(sl)
self.assertEqual(list(sl), pairs)
def test_clear(self):
size = self.size
sl = SkipList()
for i in range(size):
sl.insert(random.randint(0, 2 * size),
random.randint(0, 10 * size))
self.assertGreater(sl.level, 1)
self.assertEqual(len(sl), size)
sl.clear()
check(sl)
self.assertEqual(list(sl), [])
self.assertEqual(sl.level, 1)
def test_replace(self):
size = self.size
sl = SkipList()
values = {}
for i in range(size):
pair = (random.randint(0, 2 * size), random.randint(0, 10 * size))
sl.replace(*pair)
values[pair[0]] = pair[1]
pairs = sorted(values.items(), key=lambda x: x[0])
check(sl)
self.assertEqual(list(sl), pairs)
self.assertGreater(sl.level, 1)
def _create_skiplist(self, size, keysize, valuesize):
sl = SkipList()
pairs = []
values = {}
for i in range(size):
pair = (random.randint(0, keysize), random.randint(0, valuesize))
sl.insert(*pair)
pairs.append(pair)
if pair[0] not in values:
values[pair[0]] = []
values[pair[0]].append(pair[1])
pairs = sorted(pairs, key=lambda x: x[0])
return sl, pairs, values
def __init__(self, initlist=None, inititems=None, required=False):
"""
:param initlist: Optional. Initial data. Elements will be placed sequentallu
:param inititems: Optional. Initial items pairs.
:param required: Optional. If True, getting unset elements causes IndexError. Otherwise, unset elements will
be substituted by None. Default is False.
"""
self.data = SkipList()
self._required = required
if initlist is not None:
for i, v in enumerate(initlist):
self.data.insert(i, v)
if inititems is not None:
for i, v in inititems:
self.data.insert(i, v)
def test_level(self):
sl = SkipList()
self.assertEqual(sl.level, 1)
check(sl)
def __init__(self, preload=[]):
self.li = SkipList()
for i in preload: # init dumb
self.add(self, i)
if sys.argv[1] == 'Blist':
l = blist.sortedlist([i for i in range(10**N)])
elif sys.argv[1] == 'SortedArray':
l = SCArray._SortedArray('q', [i for i in range(10**N)])
elif sys.argv[1] == 'SortedList':
l = sortedcontainers.SortedList([i for i in range(10**N)])
elif sys.argv[1] == 'AutoLoad':
l = SCAutoBalance.SortedList([i for i in range(10**N)])
elif sys.argv[1] == 'BadBisect':
l = SCPyBisect.SortedList([i for i in range(10**N)])
elif sys.argv[1] == 'RBSTree':
l = RedBlackBST()
for i in range(10**N):
l.put(i, 1)
elif sys.argv[1] == 'SkipList':
l = SkipList()
for i in range(10**N):
l.insert(i, i)
else:
print("Error, did not supply working thingy")
exit(-1)
print(f"Testing {sys.argv[1]}")
print(len(l))
if sys.argv[3] == 'Base':
pass
elif sys.argv[3] == 'Add':
if sys.argv[1] == 'SkipList':
for i in range(1, 10**N): #No duplicates
l.insert(-i, -i)
elif sys.argv[1] == 'RBSTree':
def test_repr(self):
sl = SkipList()
sl.insert(1, 2)
sl.insert(3, 4)
self.assertEqual(repr(sl), 'SkipList(((1, 2), (3, 4)))')
check(sl)
def constructSL(aList):
"""Create SkipList from random sample."""
sl = SkipList()
for val in aList:
sl.insert(val, val)
return sl
def mem_size(self):
sl = SkipList()
self.add_result(getsize(sl))
