def insert(self, node, x):
x = x % self.u
if (self.u <= 2):
node.references[self.offset] = self
if self.min[1] == None or self.min[0] == None:
self.emptyInsert(node, x)
self.insert(node, x)
else:
if x < self.min[1]:
self.min = (self.min[0], x)
if node.value < self.min[0].value:
self.min = (node, self.min[1])
if x > self.max[1]:
self.max = (self.max[0], x)
if node.value > self.max[0].value:
self.max = (node, self.max[1])
if self.u > 2:
h = self.high(x)
if self.clusters[h] == None:
self.clusters[h] = ModVEB(self.high(self.u),
k=self.offset,
parent=self)
if self.summary == None:
self.summary = VEB(self.high(self.u))
if self.clusters[h].min[1] == None:
self.summary.insert(h)
self.clusters[h].emptyInsert(node, self.low(x))
self.clusters[h].insert(node, self.low(x))
return self.member(node, x)
def test_speed(n=DEFAULT_TEST_SIZE):
veb = VEB(n)
print('Creating VEB Tree for {} elements'.format(n))
# create random numbers
numbers = set()
for i in range(n):
number = random.randint(0, veb.u - 1)
numbers.add(number)
with Timer(message='Speed per insertion') as t:
for number in numbers:
veb.insert(number)
with Timer(message='Speed per membership query') as t:
for number in numbers:
veb.member(number)
with Timer(message='Speed per predecessor query') as t:
for number in numbers:
veb.predecessor(number)
with Timer(message='Speed per successor query') as t:
for number in numbers:
veb.successor(number)
def testInsertAllSuccessor(self):
veb = VEB(u=2**32)
A = list(range(0, 100))
veb.insertAll(A)
for a in A[:-1]:
self.assertEqual(
veb.successor(a), a + 1,
"Expected successor of {} to be {}".format(a, a + 1))
def testInsertAllPredecessor(self):
veb = VEB(u=2**32)
A = list(range(0, 100))
veb.insertAll(A)
# print(veb)
for a in A[1:]:
self.assertEqual(
veb.predecessor(a), a - 1,
"Expected predecessor of {} to be {}".format(a, a - 1))
def test_speed():
n = 50000
veb = VEB(n)
print "Creating VEB Tree for %d elements..." % n
# create random numbers
numbers = set()
for i in range(n):
number = random.randint(0, veb.u-1)
numbers.add(number)
total_time = 0
starttime = time.time()
for number in numbers:
veb.insert(number)
total_time = (time.time() - starttime)
ns = float(len(numbers))
total_time = float(total_time)
print "Speed per insertion: %f seconds" % (total_time / ns)
total_time = 0
starttime = time.time()
for number in numbers:
veb.member(number)
total_time = (time.time() - starttime)
print "Speed per membership query: %f seconds" % (total_time / ns)
total_time = 0
starttime = time.time()
for number in numbers:
veb.predecessor(number)
total_time = (time.time() - starttime)
print "Speed per predecessor query: %f seconds" % (total_time / ns)
total_time = 0
starttime = time.time()
for number in numbers:
veb.successor(number)
total_time = (time.time() - starttime)
print "Speed per successor query: %f seconds" % (total_time / ns)
def test_correctness():
n = 50000
veb = VEB(n)
print "Creating VEB Tree for %d elements..." % n
print "Testing..."
print "Generating random numbers to sample..."
# create random numbers
numbers = set()
for i in range(n):
number = random.randint(0, veb.u-1)
numbers.add(number)
# other numbers
other_numbers = set()
for i in range(n):
other_numbers.add(random.randint(0, veb.u-1))
print "Adding numbers to VEB Tree..."
# add all to set
for num in list(numbers):
veb.insert(num)
print "Testing for membership of numbers..."
# test for membership
other_numbers = other_numbers - numbers
error = 0
for num in list(other_numbers):
if veb.member(num):
error += 1
for num in list(numbers):
if not veb.member(num):
error += 1
print "Error Number For Membership was %d" % error
print "Testing for successor..."
# test for successor
listofnums = list(numbers)
listofnums.sort()
error = 0
for index in range(len(listofnums) - 1):
if veb.successor(listofnums[index]) != listofnums[index+1]:
error += 1
print "Error Number For successor was %d" % error
print "Testing for predecessor..."
# test for predecessor
error = 0
for index in range(1, len(listofnums)):
if veb.predecessor(listofnums[index]) != listofnums[index-1]:
error += 1
print "Error Number for predecessor was %d" % error
def test_correctness(n=DEFAULT_TEST_SIZE):
print('Creating VEB Tree for {} elements'.format(n))
veb = VEB(n)
print('Testing')
print('Generating random numbers to sample')
numbers = set()
for i in range(n):
number = random.randint(0, veb.u - 1)
numbers.add(number)
# Non-member numbers
non_member_numbers = set()
for i in range(n):
non_member_numbers.add(random.randint(0, veb.u - 1))
print('Adding numbers to VEB Tree')
# TODO: Implement an insert_all function
for num in numbers:
veb.insert(num)
print('Testing for membership of numbers')
# test for membership
non_member_numbers = non_member_numbers - numbers
error = 0
for num in list(non_member_numbers):
if veb.member(num):
error += 1
for num in numbers:
if not veb.member(num):
error += 1
print('Error Number For Membership was {}'.format(error))
print('Testing for successor')
# test for successor
sorted_numbers = sorted(numbers)
error = 0
for index in range(len(sorted_numbers) - 1):
if veb.successor(sorted_numbers[index]) != sorted_numbers[index + 1]:
error += 1
print('Error Number For successor was {}'.format(error))
print('Testing for predecessor')
# test for predecessor
error = 0
for index in range(1, len(sorted_numbers)):
if veb.predecessor(sorted_numbers[index]) != sorted_numbers[index - 1]:
error += 1
print('Error Number for predecessor was {}'.format(error))
def testInsert(self):
veb = VEB(u=2**32)
self.assertEqual(veb.successor(12), -1,
"Expected no successor of 12, return -1")
self.assertEqual(veb.predecessor(40), -1,
"Expected no predecessor of 12, return -1")
veb.insert(38)
self.assertEqual(veb.successor(12), 38,
"Expected successor of 12 to be 38")
self.assertEqual(veb.predecessor(40), 38,
"Expected predecessor of 40 to be 38")
def testPredecessor(self):
veb = VEB(u=2**32)
veb.insert(0)
veb.insert(1000)
veb.insert(2000)
self.assertEqual(veb.predecessor(0), -1,
"Expected no predecessor of 0, return -1")
self.assertEqual(veb.predecessor(1), 0,
"Expected predecessor of 1 to be 0")
self.assertEqual(veb.predecessor(2), 0,
"Expected predecessor of 2 to be 0")
self.assertEqual(veb.predecessor(600), 0,
"Expected predecessor of 600 to be 0")
self.assertEqual(veb.predecessor(1000), 0,
"Expected predecessor of 1000 to be 0")
self.assertEqual(veb.predecessor(1001), 1000,
"Expected predecessor of 1001 to be 1000")
self.assertEqual(veb.predecessor(1303), 1000,
"Expected predecessor of 1303 to be 1000")
self.assertEqual(veb.predecessor(2000), 1000,
"Expected predecessor of 2000 to be 1000")
self.assertEqual(veb.predecessor(2009), 2000,
"Expected predecessor of 2009 to be 2000")
self.assertEqual(
veb.predecessor(2023391), 2000,
"Expected predecessor of super large number to be maximum element")
def testSuccessor(self):
veb = VEB(u=2**64)
veb.insert(0)
veb.insert(2)
veb.insert(7)
self.assertEqual(veb.successor(0), 2,
"Expected successor of 0 to be 2")
self.assertEqual(veb.successor(1), 2,
"Expected successor of 1 to be 2")
self.assertEqual(veb.successor(2), 7,
"Expected successor of 2 to be 7")
self.assertEqual(veb.successor(3), 7,
"Expected successor of 3 to be 7")
self.assertEqual(veb.successor(6), 7,
"Expected successor of 6 to be 7")
self.assertEqual(veb.successor(7), -1,
"Expected no successor of 7, return -1")
self.assertEqual(veb.successor(8), -1,
"Expected no successor of 8, return -1")
def testDelete(self):
veb = VEB(u=2**32)
veb.insert(38)
# deleting a number that doesn't exist in VEB should not crash the DS
veb.delete(80)
self.assertEqual(veb.successor(12), 38,
"Expected successor of 12 to be 38")
self.assertEqual(veb.predecessor(40), 38,
"Expected predecessor of 40 to be 38")
veb.delete(38)
self.assertEqual(veb.successor(12), -1,
"Expected no successor of 12, return -1")
self.assertEqual(veb.predecessor(40), -1,
"Expected no predecessor of 12, return -1")
class ModVEB(VEB):
#initialized based on parent to generate ancestor list
def __init__(self, u, k=0, parent=None):
self.offset = k
if u < 0:
raise Exception("u cannot be less than 0 --- u = " + str(u))
self.u = 2
while self.u < u:
self.u *= self.u
self.min = (None, None) #(Node, x)
self.max = (None, None) #(Node, x)
if (u > 2):
self.clusters = [None
for i in range(self.high(self.u))] #modVEB trees
self.summary = None #standard VEB tree
self.parent = parent
#ancestor of 2^2^i bit universe is 2^2^{i+1} bit universe (jumping 2^i levels)
self.ancestor = parent
bitsize = np.log2(u)
for i in range(int(np.log2(bitsize) / 2)):
if self.ancestor == None:
break
self.ancestor = self.ancestor.parent
#returns a value node/false
def member(self, node, x):
x = x % self.u
if x == self.min[1] and node.value == self.min[0].value:
return self.min[0]
elif x == self.max[1] and node.value == self.max[0].value:
return self.max[0]
elif self.u <= 2:
return False
else:
cluster = self.clusters[self.high(x)]
if cluster != None:
return cluster.member(node, self.low(x))
else:
return False
#assumes x is of the same bitorder as u, finds successor in overall vEB
#e.g. when in vEB corresponding to high order bits 1101 and 11010100 is in the vEB
# returns the node containing the value 11010100 for successor(0100)
def successor(self, node, x):
x = x % self.u
if self.min[0] == None:
return None
if self.u <= 2:
if x == 0 and self.max[1] == 1 and self.max[0].value > node.value:
return self.max[0]
else:
return None
elif self.min[1] != None and x < self.min[1] and self.max[
0].value > node.value:
return self.min[0]
else:
h = self.high(x)
l = self.low(x)
maxlow = None
cluster = self.clusters[h]
if cluster != None:
maxlow = cluster.max[1]
if maxlow != None and l < maxlow:
return cluster.successor(node, l)
else:
succcluster = None
if self.summary != None:
succcluster = self.summary.successor(h)
if succcluster == None:
return None
else:
cluster2 = self.clusters[succcluster]
return cluster2.min[0]
def predecessor(self, node, x):
if self.min[0] == None:
return None
x = x % self.u
if self.u <= 2:
if x == 1 and self.min[1] == 0 and self.min[0].value < node.value:
return self.min[0]
else:
return None
elif self.max[1] != None and x > self.max[1] and self.max[
0].value < node.value:
return self.max[0]
else:
h = self.high(x)
l = self.low(x)
minlow = None
cluster = self.clusters[h]
if cluster != None:
minlow = cluster.min[1]
if minlow != None and l > minlow:
return cluster.predecessor(node, l)
else:
predcluster = None
if self.summary != None:
predcluster = self.summary.predecessor(h)
if predcluster == None:
return None
else:
cluster2 = self.clusters[predcluster]
return cluster2.max[0]
def emptyInsert(self, node, x):
x = x % self.u
self.min = (node, x)
self.max = (node, x)
def insert(self, node, x):
x = x % self.u
if (self.u <= 2):
node.references[self.offset] = self
if self.min[1] == None or self.min[0] == None:
self.emptyInsert(node, x)
self.insert(node, x)
else:
if x < self.min[1]:
self.min = (self.min[0], x)
if node.value < self.min[0].value:
self.min = (node, self.min[1])
if x > self.max[1]:
self.max = (self.max[0], x)
if node.value > self.max[0].value:
self.max = (node, self.max[1])
if self.u > 2:
h = self.high(x)
if self.clusters[h] == None:
self.clusters[h] = ModVEB(self.high(self.u),
k=self.offset,
parent=self)
if self.summary == None:
self.summary = VEB(self.high(self.u))
if self.clusters[h].min[1] == None:
self.summary.insert(h)
self.clusters[h].emptyInsert(node, self.low(x))
self.clusters[h].insert(node, self.low(x))
return self.member(node, x)