def test_readwrite_overflow(self, qty=1000):
a = Hardlocation()
b = Bitstring()
for i in range(qty):
a.write(b)
c = a.read()
self.assertEqual(b.distance_to(c), 0)
def test_readwrite_overflow(self, qty=1000):
a = Hardlocation()
b = Bitstring()
for i in range(qty):
a.write(b)
c = a.read()
self.assertEqual(b.distance_to(c), 0)
def test_average_same(self, qty=1000):
for i in range(qty):
a = Bitstring()
b = a.copy()
c = Bitstring.average(a, b)
self.assertEqual(c.distance_to(a), 0)
self.assertEqual(c.distance_to(b), 0)
def test_writeread(self, qty=10):
#sdm.initialize()
for i in range(qty):
a = Bitstring()
sdm.write(a, a)
b = sdm.read(a)
self.assertEqual(a.distance_to(b), 0)
def test_writeread(self, qty=10):
sdm.initialize()
for i in range(qty):
a = Bitstring()
sdm.thread_write(a, a)
b = sdm.thread_read(a)
self.assertEqual(a.distance_to(b), 0)
sdm.free()
def test_write_adder(self, qty=1000):
for i in range(qty):
a = Hardlocation()
b = Bitstring()
a.write(b)
self.assertEqual([ b.bitsign(i) for i in xrange(sdm.get_dimension()) ], a.adder)
a.write(b)
self.assertEqual([ 2*b.bitsign(i) for i in xrange(sdm.get_dimension()) ], a.adder)
def test_random_swap(self, qty=1000):
for i in range(qty):
a = Bitstring()
b = a.copy()
self.assertEqual(a.distance_to(b), 0)
dist = random.randint(0, sdm.get_dimension())
b.bitrandomswap(dist)
self.assertEqual(a.distance_to(b), dist)
def test_write_adder(self, qty=1000):
for i in range(qty):
a = Hardlocation()
b = Bitstring()
a.write(b)
self.assertEqual([ b.bitsign(i) for i in xrange(sdm.get_dimension()) ], a.adder)
a.write(b)
self.assertEqual([ 2*b.bitsign(i) for i in xrange(sdm.get_dimension()) ], a.adder)
def test_radius_count_intersect(self, qty=10):
sdm.initialize()
for i in range(qty):
a = Bitstring()
b = Bitstring()
cnt1 = sdm.thread_radius_count_intersect(a, b)
cnt2 = sdm.thread_radius_count_intersect(a, b)
self.assertEqual(cnt1, cnt2)
sdm.free()
def test_writereadnear(self, distance=50, qty=10):
#sdm.initialize()
for i in range(qty):
a = Bitstring()
sdm.write(a, a)
b = a.copy()
b.bitrandomswap(distance)
c = sdm.read(b)
self.assertEqual(a.distance_to(c), 0)
def test_bitset(self):
dim = sdm.get_dimension()
a = Bitstring(zero=True)
for i in range(dim):
a.bitset(i)
s = str(a)
s1 = sum([ 1 for x in s[:dim-i-1] if x == '0' ])
s2 = sum([ 1 for x in s[-i-1:] if x == '1' ])
self.assertEqual(s1+s2, dim)
def test_uniform_distribution(qty=10000):
n = sdm.get_dimension()
v = [0]*n
for i in xrange(qty):
a = Bitstring()
for j in range(n):
v[j] += a.bitsign(j)
import pylab
pylab.hist(v, bins=15)
return v
def test_uniform_distribution(qty=10000):
n = sdm.get_dimension()
v = [0] * n
for i in xrange(qty):
a = Bitstring()
for j in range(n):
v[j] += a.bitsign(j)
import pylab
pylab.hist(v, bins=15)
return v
def test_writereadnear(self, distance=50, qty=10):
sdm.initialize()
for i in range(qty):
a = Bitstring()
sdm.thread_write(a, a)
b = a.copy()
b.bitrandomswap(distance)
c = sdm.thread_read(b)
self.assertEqual(a.distance_to(c), 0)
sdm.free()
def table_7_1():
n = sdm.get_dimension()
a = Bitstring()
v = []
for i in range(550):
b = a.copy()
b.bitrandomswap(i)
v.append([i, sdm.thread_radius_count_intersect(a, b)])
print i
sys.stdout.flush()
return v
def table_7_1():
n = sdm.get_dimension()
a = Bitstring()
v = []
for i in range(550):
b = a.copy()
b.bitrandomswap(i)
v.append([ i, sdm.thread_radius_count_intersect(a, b) ])
print i
sys.stdout.flush()
return v
def test_bitstring_xor(self):
bs1 = Bitstring.init_random(1000)
bs2 = Bitstring.init_ones(1000)
bs3 = bs1.copy()
bs3.xor(bs2)
self.assertEqual(1000, bs1.distance_to(bs3))
bs2 = Bitstring.init_zeros(1000)
bs3 = bs1.copy()
bs3.xor(bs2)
self.assertEqual(0, bs1.distance_to(bs3))
def test_saveload(self):
a = Bitstring()
#sdm.initialize()
sdm.thread_write(a, a)
self.assertEqual(a.distance_to(sdm.thread_read(a)), 0)
self.assertEqual(sdm.save_to_file('_test.sdm'), 0)
sdm.free()
sdm.initialize()
self.assertTrue(a.distance_to(sdm.read(a)) > 0)
sdm.free()
self.assertEqual(sdm.initialize_from_file('_test.sdm'), 0)
self.assertEqual(a.distance_to(sdm.thread_read(a)), 0)
def test_average_random(self, qty=1000):
for i in range(qty):
a = Bitstring()
b = Bitstring()
c = Bitstring.average(a, b)
d0 = a.distance_to(b)
d1 = c.distance_to(a)
d2 = c.distance_to(b)
self.assertEqual(d1+d2, d0)
self.assertTrue(d1 < d0)
self.assertTrue(d2 < d0)
self.assertTrue(abs(d1-d2) <= 1)
def sample_radius(rounds=1, verbose=0):
if verbose > 0:
print 'Initializing SDM'
sdm.initialize()
dimension = sdm.get_dimension()
v = []
for i in xrange(rounds):
if verbose > 0:
print 'Round #%d' % (i + 1)
addr = Bitstring()
dist = sdm.distance(addr)
if verbose > 0:
print ' Processing results'
w = [0] * (dimension + 1)
for d in dist:
w[d] += 1
u = [0] * (dimension + 1)
for d, n in enumerate(w):
for j in range(d, dimension + 1):
u[j] += n
v.append(u)
sdm.free()
return v
def test_mean_distance(self, qty=10):
sdm.initialize()
for i in range(qty):
a = Bitstring()
arr = array(sdm.thread_distance(a))
self.assertTrue(abs(arr.mean() - 500) <= 1.5)
sdm.free()
def write_random(qty, use_threads=True):
w = sdm.write if not use_threads else sdm.thread_write
t0 = time()
for i in range(qty):
a = Bitstring()
print '#%d' % i, w(a, a)
t1 = time()
print 'Time:', t1 - t0, 'seconds'
def sample():
print 'Initializing SDM'
sdm.initialize()
dimension = sdm.get_dimension()
addr = Bitstring()
dist = sdm.distance(addr)
sdm.free()
return dist
def _test_sdm(self, scanner_type):
as1 = AddressSpace.init_random(1000, 1000000)
counter = Counter.init_zero(1000, 1000000)
sdm = SDM(as1, counter, 451, scanner_type)
bs1 = Bitstring.init_random(1000)
sdm.write(bs1, bs1)
bs2 = sdm.read(bs1)
self.assertEqual(0, bs1.distance_to(bs2))
def test_readwrite_swap(self, qty=1000):
for i in range(qty):
a = Hardlocation()
b = Bitstring()
a.write(b)
c = a.read()
self.assertEqual(b.distance_to(c), 0)
b.bitswap(0)
a.write(b)
a.write(b)
c = a.read()
b.bitswap(0)
self.assertEqual(b.distance_to(c), 1)
c.bitswap(0)
self.assertEqual(b.distance_to(c), 0)
def test_sdm_opencl_kernels(self):
as1 = AddressSpace.init_random(1000, 1000000)
counter = Counter.init_zero(1000, 1000000)
sdm = SDM(as1, counter, 451, sdmlib.SDM_SCANNER_OPENCL)
as1.opencl_opts.verbose = 1
for kernel in sdmlib.OPENCL_KERNEL_NAMES:
as1.set_opencl_kernel(kernel)
bs1 = Bitstring.init_random(1000)
sdm.write(bs1, bs1)
bs2 = sdm.read(bs1)
self.assertEqual(0, bs1.distance_to(bs2))
def test_readwrite_swap(self, qty=1000):
for i in range(qty):
a = Hardlocation()
b = Bitstring()
a.write(b)
c = a.read()
self.assertEqual(b.distance_to(c), 0)
b.bitswap(0)
a.write(b)
a.write(b)
c = a.read()
b.bitswap(0)
self.assertEqual(b.distance_to(c), 1)
c.bitswap(0)
self.assertEqual(b.distance_to(c), 0)
def test_bitstring_copy(self):
bs1 = Bitstring.init_random(1000)
bs2 = bs1.copy()
self.assertEqual(0, bs1.distance_to(bs2))
def test_bitstring_init_ones(self):
bs1 = Bitstring.init_ones(1000)
cnt1 = bs1.to_binary().count('1')
self.assertEqual(1000, cnt1)
def test_bitstring_init_zeros(self):
bs1 = Bitstring.init_zeros(1000)
cnt0 = bs1.to_binary().count('0')
self.assertEqual(1000, cnt0)
def test_bitstring_flip_random_bits(self):
bs1 = Bitstring.init_random(1000)
for i in range(1001):
bs2 = bs1.copy()
bs2.flip_random_bits(i)
self.assertEqual(i, bs1.distance_to(bs2))
def test_distance_random(self, qty=1000):
for i in range(qty):
a = Bitstring()
b = Bitstring()
dist = sum([ 1 for x, y in zip(str(a), str(b)) if x != y ])
self.assertEqual(Bitstring.distance(a, b), dist)
def test_distance_zero(self, qty=1000):
for i in range(qty):
a = Bitstring()
self.assertEqual(Bitstring.distance(a, a), 0)
def test_address_space(self):
as1 = AddressSpace.init_random(1000, 1000000)
bs = Bitstring.init_random(1000)
as1.scan_thread2(bs, 451)
def test_bitstring_init_random(self):
bs1 = Bitstring.init_random(1000)
cnt1 = bs1.to_binary().count('1')
self.assertLessEqual(abs(cnt1 - 500), 100)
