def setUp(self):
self.example1 = b.Node(1)
self.example2 = b.Node(2)
self.example2.insert(1)
self.example2.insert(4)
self.example2.insert(3)
self.example2.insert(5)
def is_closed(self, F=None):
if F:
Link_of_F = Link_of(self, F)
ridges_set = bst.Node()
if Link_of_F.n < 2: return True
for k in range(len(Link_of_F.facets_bin)):
facet = Link_of_F.facets_bin[k]
for element in Link_of_F.list_2_pow:
if element | facet == facet:
ridges_set.insert((element ^ facet, [k]))
closed = True
ridges_data_list = []
ridges_set.TreeToList(ridges_data_list)
for ridge_data in ridges_data_list:
if len(ridge_data[1]) != 2:
closed = False
break
return closed
else:
if not self.FP_bin:
ridges_set = bst.Node()
if self.n < 2: return True
for k in range(len(self.facets_bin)):
facet = self.facets_bin[k]
for element in self.list_2_pow:
if element | facet == facet:
ridges_set.insert((element ^ facet, [k]))
ridges_data_list = []
ridges_set.TreeToList(ridges_data_list)
else:
ridges_data_list = self.FP_bin[self.n - 2]
closed = True
for ridge_data in ridges_data_list:
if len(ridge_data[1]) != 2:
closed = False
break
return closed
def list_unclosed_ridges(self):
if not self.unclosed_ridges:
ridges_set = bst.Node()
if self.n < 2: return []
for k in range(len(self.facets_bin)):
facet = self.facets_bin[k]
for element in self.list_2_pow:
if element | facet == facet:
ridges_set.insert((element ^ facet, [k + 1]))
ridges_data_list = []
ridges_set.TreeToList(ridges_data_list)
unclosed_ridges = []
for ridge_data in ridges_data_list:
if len(ridge_data[1]) != 2:
unclosed_ridges.append(ridge_data[0])
unclosed_ridges.sort()
self.unclosed_ridges = unclosed_ridges
def create_FP(self):
if not self.FP_bin:
self.FP_bin = [[] for i in range(self.n)]
faces_set = [bst.Node() for k in range(self.n)]
facet_data = [(facet, []) for facet in self.facets_bin]
faces_set[-1].insertList(facet_data)
for k in range(self.n - 2, -1, -1): # dimension
faces = []
faces_set[k + 1].TreeToList(faces)
self.FP_bin[k + 1] = faces.copy()
for l in range(len(faces)): # treat every face of dimension k
face = faces[l][0]
for element in self.list_2_pow[:self.
m]: # construct the (k-1)-subfaces
if element | face == face:
subface = element ^ face
faces_set[k].insert((subface, [l]))
vertices = []
faces_set[0].TreeToList(vertices)
self.FP_bin[0] = vertices.copy()
def faces_set_to_MNF_set(self):
if not self.FP_bin:
self.create_FP()
temp_faces_list = [list_2_pow[self.m] - 1]
k = self.m
subface_set = bst.Node()
subface_set.insertList(temp_faces_list)
# we enumerate all the faces until the time we will have the right dimension faces
while k > self.n:
subface_set = bst.Node()
for face in temp_faces_list: # treat every face of dimension k
for element in self.list_2_pow[:self.
m]: # construct the (k-1)-subfaces
if element | face == face:
subface = element ^ face
if not subface_set.findval(subface):
if k > self.n or (
k == self.n and
(not dichotomie(self.FP_bin[k - 1], subface))):
subface_set.insert((subface, []))
temp_faces_list_data = []
subface_set.TreeToList(temp_faces_list_data)
temp_faces_list = [data[0] for data in temp_faces_list_data]
k = k - 1
# we then create the set with all subsets of [m] of size <= n not in the given faces set
all_non_faces = [bst.Node() for k in range(self.n + 1)]
all_non_faces[-1] = subface_set
for k in range(self.n - 1, -1, -1): # dimension
faces_data = []
all_non_faces[k + 1].TreeToList(faces_data)
faces = [data[0] for data in faces_data]
for l in range(len(faces)): # treat every face of dimension k
face = faces[l]
for element in self.list_2_pow[:self.
m]: # construct the (k-1)-subfaces
if element | face == face:
subface = element ^ face
if (not (all_non_faces[k].findval(subface))) and (
not dichotomie(self.FP_bin[k],
subface)): # needs to be fixed
all_non_faces[k].insert((subface, [l + 1]))
MNF_set = bst.Node()
# Here we will try every face of dimension k
for k in range(1, self.n + 1):
faces_to_test_data = []
all_non_faces[k].TreeToList(faces_to_test_data)
faces_to_test = [data[0] for data in faces_to_test_data]
for face_to_test in faces_to_test:
is_MNF = True
for element in self.list_2_pow[:self.
m]: # construct the (k-1)-subfaces
if element | face_to_test == face_to_test:
subface = element ^ face_to_test
if not (dichotomie(subface, self.FP_bin[k - 1])):
is_MNF = False
break
if is_MNF:
MNF_set.insert((face_to_test, [1]))
self.MNF_set_bin = []
MNF_set.TreeToList(self.MNF_set_bin)
self.MNF_set_bin = self.MNF_set_bin[:][0]
def build_tree():
tree = AVL_tree() #建立一个树的实体
for i in range(len(A)):
node = binary_search_tree.Node(data=A[i], name=i) #建立一个节点的实体
tree.add(node) #将节点加入树中
return tree
def test_return_type_error_if_value_is_not_basic_data_type(self):
with self.assertRaises(TypeError):
self.example1.insert([])
with self.assertRaises(TypeError):
self.example1.insert(b.Node(3))