def find_triangles(radius): radius2 = radius ** 2 # generate points in circle, except origin r = range(-radius + 1, radius) points = set() for x in r: for y in r: if mag2(x, y) < radius2: points.add((x, y)) points.remove((0,0)) #print(points) triangles = set() for p1, p2 in all_pairs(points): # test if p1-p2 crosses the origin if cmp_line(p1, p2, (0,0)) == 0: continue # get the set of points p3 that is on the side of the line p1-(0,0) # farthest from p2, and likewise for p2-(0,0). each of these points # completes a triangle (p1, p2, p3) that contains the origin. #TODO prevent duplication of triangles, reducing reliance on sets p3_set = (partition(points, p1, (0,0), p2)[1] & partition(points, p2, (0,0), p1)[1]) for p3 in p3_set: triangles.add(frozenset((p1, p2, p3))) return len(triangles)
def _cutout2(self, itemType, manager): if self.flagged: inner, outer = partition(lambda item: item.flagged, self) if itemType + 1 == self.itemType: cutSubitem = self.newSubitem() for subitem in inner: subinner, subouter = partition(lambda item: item.flagged, subitem) cutSubitem.addSubitems(subinner) if subouter: restSubitem = self.newSubitem() restSubitem.addSubitems(subouter) outer.append(restSubitem) outer.append(cutSubitem) self.setSubitems(outer, False, manager) elif itemType + 1 < self.itemType: if len(inner) == 1: inner[0]._cutout2(itemType, manager) else: newSubitem = self.newSubitem() for subitem in inner: newSubitem.addSubitems(subitem) newSubitem.flagged += subitem.flagged newSubitem._cutout2(itemType, manager) outer.append(newSubitem) self.setSubitems(outer, False, manager)
def _cutout(self, itemType, cutItem, manager): if self.flagged: if itemType == self.itemType: inner, outer = partition(lambda item: item.flagged, self) cutItem.addSubitems(inner) self.setSubitems(outer, True, manager) elif itemType < self.itemType: newSubitems = [] if cutItem is None: if itemType + 1 == self.itemType or self.flagged > 1: hints = [subitem for subitem in self if subitem.flagged] it = cutSubitem = self.newSubitem(hints) while it.itemType != itemType: it.addSubitem(it.newSubitem(), False) it = it[0] newSubitems.append(cutSubitem) else: cutSubitem = None else: cutSubitem = cutItem[0] for subitem in self: subitem._cutout(itemType, cutSubitem, manager) if subitem: newSubitems.append(subitem) if cutItem is None and cutSubitem is not None: def computeBounds(item): if item.itemType != itemType: for subitem in item: computeBounds(subitem) item.recomputeBounds() computeBounds(cutSubitem) self.setSubitems(newSubitems, True, manager)
def inner(fn, args): models, params = partition(is_model, args) return Model( fn, list(models) + [filter_for_required_args(fn, p, sanitize_label) for p in params], )
def search(points): for a, b in all_cuts(points, size): left, right = partition(points, a, b) for c in search(left): yield c yield (a, b) for c in search(right): yield c
def merge(self, itemType, manager): if itemType < self.itemType and self.flagged: inner, outer = partition(lambda item: item.flagged, self) if len(inner) == 1: inner[0].merge(itemType, manager) else: newSubitem = self.newSubitem(hints=inner) for subitem in inner: newSubitem.addSubitems(subitem) newSubitem.flagged += subitem.flagged newSubitem.merge(itemType, manager) outer.append(newSubitem) self.setSubitems(outer, False, manager)
def build_tree(self, D, questions, depth, t_col): """ Recursion function of the decision tree. It figures out the decision nodes and leaf nodes. Parameters ---------- D : numpy.array Dataset questions : list List of questions for each feature in the data set Returns ------- Decision Node or Leaf Node Node of the tree. """ # index of which question should be asked in order to split the tree split_col = 0 max_gain = 0 question = questions[0] for i in range(0, len(questions)): # calculate information gain for a certain feature gain = information_gain(D=D, question=questions[i], t_col=t_col) # TODO determine column where you want to make split # TODO assign that column to split_col variable if gain > max_gain: max_gain = gain split_col = i # end of the tree reached if max_gain == 0: return leaf_node(D=D, depth=depth, t_col=t_col) # analyze true and false examples self.depth += 1 # grow tree in depth (true_rows, false_rows) = partition(D=D, question=questions[split_col]) true_branch = self.build_tree(D=true_rows, questions=questions, depth=depth + 1, t_col=t_col) false_branch = self.build_tree(D=false_rows, questions=questions, depth=depth + 1, t_col=t_col) return decision_node(question=questions[split_col], true_branch=true_branch, false_branch=false_branch, depth=depth, D=D, t_col=t_col)
def _cutout(self, itemType, cutItem, manager): if self.flagged: if itemType == self.itemType: inner, outer = partition(lambda item: item.flagged, self) cutItem.addSubitems(inner) self.setSubitems(outer, True, manager) elif itemType < self.itemType: newSubitems = [] if cutItem is None: if itemType + 1 == self.itemType or self.flagged > 1: hints = [ subitem for subitem in self if subitem.flagged ] it = cutSubitem = self.newSubitem(hints) while it.itemType != itemType: it.addSubitem(it.newSubitem(), False) it = it[0] newSubitems.append(cutSubitem) else: cutSubitem = None else: cutSubitem = cutItem[0] for subitem in self: subitem._cutout(itemType, cutSubitem, manager) if subitem: newSubitems.append(subitem) if cutItem is None and cutSubitem is not None: def computeBounds(item): if item.itemType != itemType: for subitem in item: computeBounds(subitem) item.recomputeBounds() computeBounds(cutSubitem) self.setSubitems(newSubitems, True, manager)