def setUpClass(cls):
cls.lim1 = 8
cls.lim2 = 3
cls.lim3 = 4
cls.link_num = 4
cls.points1 = [(float(i) / cls.lim1, ) for i in range(cls.lim1)]
cls.links1 = {
p: [
cls.points1[l] for l in
[random.randint(0, cls.lim1 - 1) for x in range(cls.link_num)]
]
for p in cls.points1
}
cls.points2 = [(float(i) / cls.lim2, float(j) / cls.lim2)
for i in range(cls.lim2) for j in range(cls.lim2)]
cls.links2 = {
p: [
cls.points2[l] for l in [
random.randint(0, cls.lim2**2 - 1)
for x in range(cls.link_num)
]
]
for p in cls.points2
}
cls.points3 = [(float(i) / cls.lim3, float(j) / cls.lim3,
float(k) / cls.lim3) for i in range(cls.lim3)
for j in range(cls.lim3) for k in range(cls.lim3)]
cls.links3 = {
p: [
cls.points3[l] for l in [
random.randint(0, cls.lim3**3 - 1)
for x in range(cls.link_num)
]
]
for p in cls.points3
}
cls.grid1 = Grid(cls.points1, cls.links1)
cls.grid2 = Grid(cls.points2, cls.links2)
cls.grid3 = Grid(cls.points3, cls.links3)
cls.cluster1 = Cluster(cls.grid1)
cls.cluster2 = Cluster(cls.grid2)
cls.cluster3 = Cluster(cls.grid3)
cls.cub1 = Cuboid(numpy.array([0]), numpy.array([1]))
cls.cub2 = Cuboid(numpy.array([0, 0]), numpy.array([1, 1]))
cls.cub3 = Cuboid(numpy.array([0, 0, 0]), numpy.array([1, 1, 1]))
cls.rc1 = RegularCuboid(cls.cluster1)
cls.rc2 = RegularCuboid(cls.cluster2)
cls.rc3 = RegularCuboid(cls.cluster3)
cls.ct1 = build_cluster_tree(cls.rc1)
cls.ct2 = build_cluster_tree(cls.rc2)
cls.ct3 = build_cluster_tree(cls.rc3)
cls.bct1 = build_block_cluster_tree(cls.ct1,
right_cluster_tree=cls.ct1,
admissible_function=admissible)
cls.bct2 = build_block_cluster_tree(cls.ct2,
right_cluster_tree=cls.ct2,
admissible_function=admissible)
cls.bct3 = build_block_cluster_tree(cls.ct3,
right_cluster_tree=cls.ct3,
admissible_function=admissible)
def test_distance(self):
dist_check = numpy.linalg.norm(
numpy.array([2 - float(self.lim1 - 1) / self.lim1]))
dist_points = [
numpy.array([2 + float(i) / self.lim1]) for i in range(self.lim1)
]
dist_links = [[
dist_points[l] for l in
[random.randint(0, self.lim1 - 1) for x in range(self.link_num)]
] for i in range(self.lim1)]
dist_grid = Grid(dist_points, dist_links)
dist_cluster = Cluster(dist_grid)
dist_rc = RegularCuboid(dist_cluster)
dist_ct = ClusterTree(dist_rc, 1)
self.assertEqual(self.ct1.distance(dist_ct), dist_check)
dist_points = [
numpy.array([2 + float(i) / self.lim2, 2 + float(j) / self.lim2])
for i in range(self.lim2) for j in range(self.lim2)
]
dist_links = [[
dist_points[l] for l in [
random.randint(0, (self.lim2 - 1)**2)
for x in range(self.link_num)
]
] for j in range(self.lim2) for i in range(self.lim2)]
dist_grid = Grid(dist_points, dist_links)
dist_cluster = Cluster(dist_grid)
dist_check = numpy.linalg.norm(
numpy.array([
2 - float(self.lim2 - 1) / self.lim2,
2 - float(self.lim2 - 1) / self.lim2
]))
dist_rc = RegularCuboid(dist_cluster)
dist_ct = ClusterTree(dist_rc, 1)
self.assertEqual(self.ct2.distance(dist_ct), dist_check)
dist_points = [
numpy.array([
2 + float(i) / self.lim3, 2 + float(j) / self.lim3,
2 + float(k) / self.lim3
]) for i in range(self.lim3) for j in range(self.lim3)
for k in range(self.lim3)
]
dist_links = [[
dist_points[l] for l in [
random.randint(0, (self.lim3 - 1)**3)
for x in range(self.link_num)
]
] for k in range(self.lim3) for j in range(self.lim3)
for i in range(self.lim3)]
dist_grid = Grid(dist_points, dist_links)
dist_cluster = Cluster(dist_grid)
dist_check = numpy.linalg.norm(
numpy.array([
2 - float(self.lim3 - 1) / self.lim3,
2 - float(self.lim3 - 1) / self.lim3,
2 - float(self.lim3 - 1) / self.lim3
]))
dist_rc = RegularCuboid(dist_cluster)
dist_ct = ClusterTree(dist_rc, 1)
self.assertEqual(self.ct3.distance(dist_ct), dist_check)
def setUpClass(cls):
cls.dummy = Splitable()
cls.lim1 = 16
cls.lim2 = 8
cls.lim3 = 4
cls.link_num = 4
cls.points1 = [(float(i) / cls.lim1, ) for i in range(cls.lim1)]
cls.links1 = {
p: [
cls.points1[l] for l in
[random.randint(0, cls.lim1 - 1) for x in range(cls.link_num)]
]
for p in cls.points1
}
cls.points2 = [(float(i) / cls.lim2, float(j) / cls.lim2)
for i in range(cls.lim2) for j in range(cls.lim2)]
cls.links2 = {
p: [
cls.points2[l] for l in [
random.randint(0, cls.lim2**2 - 1)
for x in range(cls.link_num)
]
]
for p in cls.points2
}
cls.points3 = [(float(i) / cls.lim3, float(j) / cls.lim3,
float(k) / cls.lim3) for i in range(cls.lim3)
for j in range(cls.lim3) for k in range(cls.lim3)]
cls.links3 = {
p: [
cls.points3[l] for l in [
random.randint(0, cls.lim3**3 - 1)
for x in range(cls.link_num)
]
]
for p in cls.points3
}
cls.grid1 = Grid(cls.points1, cls.links1)
cls.grid2 = Grid(cls.points2, cls.links2)
cls.grid3 = Grid(cls.points3, cls.links3)
cls.cluster1 = Cluster(cls.grid1)
cls.cluster2 = Cluster(cls.grid2)
cls.cluster3 = Cluster(cls.grid3)
cls.rc1 = RegularCuboid(cls.cluster1)
cls.rc2 = RegularCuboid(cls.cluster2)
cls.rc3 = RegularCuboid(cls.cluster3)
cls.mc1 = MinimalCuboid(cls.cluster1)
cls.mc2 = MinimalCuboid(cls.cluster2)
cls.mc3 = MinimalCuboid(cls.cluster3)
cls.ba1 = Balanced(cls.cluster1)
cls.ba2 = Balanced(cls.cluster2)
cls.ba3 = Balanced(cls.cluster3)
def main(args):
lim1 = 0
lim2 = 0
lim3 = 0
if args.dimension >= 1:
lim1 = args.limit
if args.dimension >= 2:
lim2 = args.limit
if args.dimension == 3:
lim3 = args.limit if args.dimension > 2 else 0
link_num = 2
if args.dimension == 1:
points = [np.array([float(i) / lim1]) for i in range(lim1)]
links = [[points[l] for l in [random.randint(0, lim1 - 1) for x in range(link_num)]] for i in range(lim1)]
elif args.dimension == 2:
points = [np.array([float(i) / lim1, float(j) / lim2]) for i in range(lim1) for j in range(lim2)]
links = [[points[l] for l in [random.randint(0, lim1 * lim2 - 2) for x in range(link_num)]]
for i in range(lim1) for j in range(lim2)]
else:
points = [np.array([float(i) / lim1, float(j) / lim2, float(k) / lim3]) for i in range(lim1) for j in
range(lim2) for k in range(lim3)]
links = [[points[l] for l in [random.randint(0, lim1 * lim2 * lim3 - 1) for x in range(link_num)]]
for k in range(lim3) for j in range(lim2) for i in range(lim1)]
grid = Grid(points, links)
cluster = Cluster(grid)
rc = RegularCuboid(cluster)
start = timer()
ct = ClusterTree(rc, 1)
end = timer()
print("ClusterTree build-up took " + str(end - start))
start = timer()
bct = BlockClusterTree(ct, ct)
end = timer()
print("BlockClusterTree buil-up took " + str(end - start))
def test_build_hmatrix(self):
full_func = lambda x: numpy.matrix(numpy.ones(x.shape()))
block_func = lambda x: RMat(numpy.matrix(numpy.ones((x.shape()[0], 1))),
numpy.matrix(numpy.ones((x.shape()[1], 1))),
max_rank=1)
lim1 = 2
link_num = 4
points1 = [numpy.array([float(i) / lim1]) for i in range(lim1)]
links1 = [[points1[l] for l in [random.randint(0, lim1 - 1) for x in range(link_num)]] for i in range(lim1)]
grid1 = Grid(points1, links1)
cluster1 = Cluster(grid1)
rc1 = RegularCuboid(cluster1)
ct1 = build_cluster_tree(rc1, max_leaf_size=4)
bct1 = build_block_cluster_tree(ct1, right_cluster_tree=ct1, admissible_function=admissible)
hmat = build_hmatrix(bct1, generate_rmat_function=block_func, generate_full_matrix_function=block_func)
check_rmat = RMat(numpy.matrix(numpy.ones((2, 1))), numpy.matrix(numpy.ones((2, 1))), max_rank=1)
check = HMat(content=check_rmat, shape=(2, 2), parent_index=(0, 0))
self.assertEqual(hmat, check)
lim1 = 8
link_num = 4
points1 = [numpy.array([float(i) / lim1]) for i in range(lim1)]
links1 = [[points1[l] for l in [random.randint(0, lim1 - 1) for x in range(link_num)]] for i in range(lim1)]
grid1 = Grid(points1, links1)
cluster1 = Cluster(grid1)
rc1 = RegularCuboid(cluster1)
ct1 = build_cluster_tree(rc1, max_leaf_size=4)
bct1 = build_block_cluster_tree(ct1, right_cluster_tree=ct1, admissible_function=admissible)
hmat = build_hmatrix(bct1, generate_rmat_function=block_func, generate_full_matrix_function=block_func)
check_rmat = RMat(numpy.matrix(numpy.ones((4, 1))), numpy.matrix(numpy.ones((4, 1))), max_rank=1)
check1 = HMat(content=check_rmat, shape=(4, 4), parent_index=(0, 0))
check2 = HMat(content=check_rmat, shape=(4, 4), parent_index=(0, 4))
check3 = HMat(content=check_rmat, shape=(4, 4), parent_index=(4, 0))
check4 = HMat(content=check_rmat, shape=(4, 4), parent_index=(4, 4))
check = HMat(blocks=[check1, check2, check3, check4], shape=(8, 8), parent_index=(0, 0))
self.assertEqual(hmat, check)
bct1 = build_block_cluster_tree(ct1, right_cluster_tree=ct1, admissible_function=lambda x, y: True)
hmat = build_hmatrix(bct1, generate_rmat_function=block_func, generate_full_matrix_function=block_func)
self.assertIsInstance(hmat, HMat)
def test_distance(self):
self.assertRaises(NotImplementedError, self.dummy.distance, self.dummy)
dist_check = numpy.linalg.norm(
numpy.array([2 - float(self.lim1 - 1) / self.lim1]))
dist_points = [
numpy.array([2 + float(i) / self.lim1]) for i in range(self.lim1)
]
dist_links = [[
dist_points[l] for l in
[random.randint(0, self.lim1 - 1) for x in range(self.link_num)]
] for i in range(self.lim1)]
dist_grid = Grid(dist_points, dist_links)
dist_cluster = Cluster(dist_grid)
dist_rc = RegularCuboid(dist_cluster)
self.assertEqual(self.rc1.distance(dist_rc), dist_check)
self.assertEqual(self.mc1.distance(dist_rc), dist_check)
self.assertEqual(self.ba1.distance(dist_rc), dist_check)
dist_points = [
numpy.array([2 + float(i) / self.lim2, 2 + float(j) / self.lim2])
for i in range(self.lim2) for j in range(self.lim2)
]
dist_links = [[
dist_points[l] for l in [
random.randint(0, (self.lim2 - 1)**2)
for x in range(self.link_num)
]
] for j in range(self.lim2) for i in range(self.lim2)]
dist_grid = Grid(dist_points, dist_links)
dist_cluster = Cluster(dist_grid)
dist_check = numpy.linalg.norm(
numpy.array([
2 - float(self.lim2 - 1) / self.lim2,
2 - float(self.lim2 - 1) / self.lim2
]))
dist_rc = RegularCuboid(dist_cluster)
self.assertEqual(self.rc2.distance(dist_rc), dist_check)
self.assertEqual(self.mc2.distance(dist_rc), dist_check)
self.assertEqual(self.ba2.distance(dist_rc), dist_check)
dist_points = [
numpy.array([
2 + float(i) / self.lim3, 2 + float(j) / self.lim3,
2 + float(k) / self.lim3
]) for i in range(self.lim3) for j in range(self.lim3)
for k in range(self.lim3)
]
dist_links = [[
dist_points[l] for l in [
random.randint(0, (self.lim3 - 1)**3)
for x in range(self.link_num)
]
] for k in range(self.lim3) for j in range(self.lim3)
for i in range(self.lim3)]
dist_grid = Grid(dist_points, dist_links)
dist_cluster = Cluster(dist_grid)
dist_check = numpy.linalg.norm(
numpy.array([
2 - float(self.lim3 - 1) / self.lim3,
2 - float(self.lim3 - 1) / self.lim3,
2 - float(self.lim3 - 1) / self.lim3
]))
dist_rc = RegularCuboid(dist_cluster)
self.assertEqual(self.rc3.distance(dist_rc), dist_check)
self.assertEqual(self.mc3.distance(dist_rc), dist_check)
self.assertEqual(self.ba3.distance(dist_rc), dist_check)
def test_split(self):
self.assertRaises(NotImplementedError, self.dummy.split)
left_cluster = Cluster(self.grid1,
self.cluster1.indices[:self.lim1 / 2])
right_cluster = Cluster(self.grid1,
self.cluster1.indices[self.lim1 / 2:])
left_cub = Cuboid(
numpy.array([0]),
numpy.array([float(self.lim1 - 1) / (2 * self.lim1)]))
right_cub = Cuboid(
numpy.array([float(self.lim1 - 1) / (2 * self.lim1)]),
numpy.array([float(self.lim1 - 1) / self.lim1]))
left_rc = RegularCuboid(left_cluster, left_cub)
right_rc = RegularCuboid(right_cluster, right_cub)
left_split, right_split = self.rc1.split()
self.assertEqual(left_rc, left_split)
self.assertEqual(right_rc, right_split)
left_split, right_split = self.mc1.split()
left_mc = MinimalCuboid(left_cluster)
right_mc = MinimalCuboid(right_cluster)
self.assertEqual(left_split, left_mc)
self.assertEqual(right_split, right_mc)
left_split, right_split = self.ba1.split()
left_ba = Balanced(left_cluster)
right_ba = Balanced(right_cluster)
self.assertEqual(left_ba, left_split)
self.assertEqual(right_ba, right_split)
left_cluster = Cluster(self.grid2,
self.cluster2.indices[:self.lim2**2 / 2])
right_cluster = Cluster(self.grid2,
self.cluster2.indices[self.lim2**2 / 2:])
left_cub = Cuboid(
numpy.array([0, 0]),
numpy.array([
float(self.lim2 - 1) / (2 * self.lim2),
float(self.lim2 - 1) / self.lim2
]))
right_cub = Cuboid(
numpy.array([float(self.lim2 - 1) / (2 * self.lim2), 0]),
numpy.array([
float(self.lim2 - 1) / self.lim2,
float(self.lim2 - 1) / self.lim2
]))
left_rc = RegularCuboid(left_cluster, left_cub)
right_rc = RegularCuboid(right_cluster, right_cub)
left_split, right_split = self.rc2.split()
self.assertEqual(left_rc, left_split)
self.assertEqual(right_rc, right_split)
left_split, right_split = self.mc2.split()
left_mc = MinimalCuboid(left_cluster)
right_mc = MinimalCuboid(right_cluster)
self.assertEqual(left_mc, left_split)
self.assertEqual(right_mc, right_split)
left_split, right_split = self.ba2.split()
left_ba = Balanced(left_cluster)
right_ba = Balanced(right_cluster)
self.assertEqual(left_ba, left_split)
self.assertEqual(right_ba, right_split)
left_cluster = Cluster(self.grid3,
self.cluster2.indices[:self.lim3**3 / 2])
right_cluster = Cluster(self.grid3,
self.cluster2.indices[self.lim3**3 / 2:])
left_cub = Cuboid(
numpy.array([0, 0, 0]),
numpy.array([
float(self.lim3 - 1) / (2 * self.lim3),
float(self.lim3 - 1) / self.lim3,
float(self.lim3 - 1) / self.lim3
]))
right_cub = Cuboid(
numpy.array([float(self.lim3 - 1) / (2 * self.lim3), 0, 0]),
numpy.array([
float(self.lim3 - 1) / self.lim3,
float(self.lim3 - 1) / self.lim3,
float(self.lim3 - 1) / self.lim3
]))
left_rc = RegularCuboid(left_cluster, left_cub)
right_rc = RegularCuboid(right_cluster, right_cub)
left_split, right_split = self.rc3.split()
self.assertEqual(left_rc, left_split)
self.assertEqual(right_rc, right_split)
left_split, right_split = self.mc3.split()
left_mc = MinimalCuboid(left_cluster)
right_mc = MinimalCuboid(right_cluster)
self.assertEqual(left_mc, left_split)
self.assertEqual(right_mc, right_split)
left_split, right_split = self.ba3.split()
left_ba = Balanced(left_cluster)
right_ba = Balanced(right_cluster)
self.assertEqual(left_ba, left_split)
self.assertEqual(right_ba, right_split)
grid = Grid([0, 1, 5], [[1], [5], [0]])
clust = Cluster(grid)
regcub = RegularCuboid(clust)
split1, split2 = regcub.split()
split3 = split1.split()
split4 = split2.split()
self.assertEqual(len(split3), 1)
self.assertEqual(len(split4), 1)
test_ba = Balanced(split4[0].cluster)
self.assertEqual(test_ba.split(), test_ba)
# points2 = points2left + points2top + points2right + points2bottom
points2 = [
np.array([
math.cos(2 * math.pi * (float(i) / lim2)),
math.sin(2 * math.pi * (float(i) / lim2))
]) for i in range(lim2)
]
links2 = [[points2[i + 1]] for i in range(len(points2) - 1)]
links2.append([points2[0]])
grid2 = Grid(points2, links2)
grid2.plot('GridPlot.png')
cluster2 = Cluster(grid2)
rc2 = RegularCuboid(cluster2, )
ct2 = build_cluster_tree(rc2)
ct2.export('dot', 'out2.dot')
bct2 = build_block_cluster_tree(ct2)
# bct2.export('dot', 'out2.dot')
bct2.plot('plotUnitCircle256.png', face_color='#ffffff')
# lim3 = 2 ** 2
# points3 = [np.array([float(i) / lim3, float(j) / lim3, float(k) / lim3]) for i in xrange(lim3) for j in
# xrange(lim3) for k in xrange(lim3)]
# links3 = [[points3[l] for l in [random.randint(0, (lim3 - 1) ** 3) for x in xrange(link_num)]]
# for k in xrange(lim3) for j in xrange(lim3) for i in xrange(lim3)]
# grid3 = Grid(points3, links3)
# cluster3 = Cluster(grid3)
# rc3 = RegularCuboid(cluster3)
# ct3 = build_cluster_tree(rc3)
def setUpClass(cls):
cls.lim1 = 16
cls.lim2 = 4
cls.lim3 = 4
cls.link_num = 4
cls.points1 = [(float(i) / cls.lim1, ) for i in range(cls.lim1)]
cls.links1 = {
p: [
cls.points1[l] for l in
[random.randint(0, cls.lim1 - 1) for x in range(cls.link_num)]
]
for p in cls.points1
}
cls.points2 = [(float(i) / cls.lim2, float(j) / cls.lim2)
for i in range(cls.lim2) for j in range(cls.lim2)]
cls.links2 = {
p: [
cls.points2[l] for l in [
random.randint(0, cls.lim2**2 - 1)
for x in range(cls.link_num)
]
]
for p in cls.points2
}
cls.points3 = [(float(i) / cls.lim3, float(j) / cls.lim3,
float(k) / cls.lim3) for i in range(cls.lim3)
for j in range(cls.lim3) for k in range(cls.lim3)]
cls.links3 = {
p: [
cls.points3[l] for l in [
random.randint(0, cls.lim3**3 - 1)
for x in range(cls.link_num)
]
]
for p in cls.points3
}
cls.grid1 = Grid(cls.points1, cls.links1)
cls.grid2 = Grid(cls.points2, cls.links2)
cls.grid3 = Grid(cls.points3, cls.links3)
cls.cluster1 = Cluster(cls.grid1)
cls.cluster2 = Cluster(cls.grid2)
cls.cluster3 = Cluster(cls.grid3)
cls.cub1 = Cuboid(numpy.array([0]), numpy.array([1]))
cls.cub2 = Cuboid(numpy.array([0, 0]), numpy.array([1, 1]))
cls.cub3 = Cuboid(numpy.array([0, 0, 0]), numpy.array([1, 1, 1]))
cls.rc1 = RegularCuboid(cls.cluster1)
cls.rc2 = RegularCuboid(cls.cluster2)
cls.rc3 = RegularCuboid(cls.cluster3)
cls.ct1 = build_cluster_tree(cls.rc1, 4)
cls.ct2 = build_cluster_tree(cls.rc2, 4)
cls.ct3 = build_cluster_tree(cls.rc3, 4)
cls.bct1 = build_block_cluster_tree(cls.ct1,
cls.ct1,
admissible_function=admissible)
cls.bct2 = build_block_cluster_tree(cls.ct2,
cls.ct2,
admissible_function=admissible)
cls.bct3 = build_block_cluster_tree(cls.ct3,
cls.ct3,
admissible_function=admissible)
def build_full(x):
return numpy.matrix(numpy.ones(x.shape()))
def build_rmat(x):
return RMat(numpy.matrix(numpy.ones((x.shape()[0], 1))),
numpy.matrix(numpy.ones((x.shape()[1], 1))),
max_rank=1)
cls.hmat1 = build_hmatrix(cls.bct1, build_rmat, build_full)
cls.hmat2 = build_hmatrix(cls.bct2, build_rmat, build_full)
cls.hmat3 = build_hmatrix(cls.bct3, build_rmat, build_full)