Esempio n. 1
0
def test_set_points(pts, t):
    test_set = []
    rand_pts = random.sample(pts, min(int(math.sqrt(2 * t) + 1), len(pts)))
    for p1, p2 in itertools.combinations(rand_pts, 2):
        if len(test_set) >= t:
            break
        test_set.append(St.to_line(p1, p2))
    return test_set
Esempio n. 2
0
 def gen():
     for p1, p2 in itertools.combinations(net_sample, 2):
         l = to_line(p1, p2)
         r = sum(w for p, w in zip(red_points, red_weights)
                 if l.pt_eq_below(p))
         b = sum(w for p, w in zip(blue_points, blue_weights)
                 if l.pt_eq_below(p))
         yield stat(r / nr, b / nb), l
Esempio n. 3
0
    def __init__(self, pts):

        self.angle_orders = []
        self.pts = pts
        self.lines = []
        for i in range(len(pts) - 1):
            pt = pts[i]
            pt_order = pts[:i] + pts[(i + 1):]
            pt_order.sort(key=lambda x: order_function(pt, x))
            angle_order = []
            lines = []
            for j in range(len(pt_order)):
                try:
                    l = to_line(pt, pt_order[j])
                except ZeroDivisionError:
                    continue
                angle_order.append(order_function(pt, pt_order[j]))
                lines.append(l)
            self.angle_orders.append(angle_order)
            self.lines.append(lines)
Esempio n. 4
0
def test_set_lines(pts, t):
    test_set = []
    t = min(t, int(len(pts) / 2))
    rand_pts = random.sample(pts, 2 * t)

    for p1, p2 in zip(rand_pts[:t], rand_pts[t:]):
        test_set.append(St.to_line(p1, p2))
    return test_set


#
# import matplotlib.pyplot as plt
#
# pts = [(random.random(), random.random()) for i in range(10000)]
#
# lines = test_set_dual_exact_t(pts, 100)
# print(len(lines))
# f, ax = plt.subplots()
# for l in lines:
#     l.visualize(ax, -1, 1)
# ax.set_xlim([-1, 1])
# ax.set_ylim([-1, 1])
# plt.show()
Esempio n. 5
0
def random_test_set(pts, t, c=10):
    test_set = []
    for i in range(int(t * t) * c):
        p1, p2 = random.sample(pts, 2)
        test_set.append(to_line(p1, p2))
    return test_set
Esempio n. 6
0
def line_discrepancy(net_sample,
                     red_points,
                     red_weights,
                     blue_points,
                     blue_weights,
                     disc=stat):
    """
    :param big_samp:
    :param small_samp:
    :param weights:
    :param pt_num:
    :param n: The sub-sampling size of the small sample.
    :return:
    """
    #net_sample = random.sample(blue_points, n // 2) + random.sample(red_points, n // 2)
    max_discrepancy = -math.inf
    max_line = Line(0, 0)
    a = 0
    b = 0
    if red_weights:
        a = 1.0 / sum(red_weights)
    if blue_weights:
        b = 1.0 / sum(blue_weights)

    for i in range(len(net_sample) - 1):
        sample_part = net_sample[i + 1:]

        p_0 = net_sample[i]
        order_f = lambda x: order_function(p_0, x)

        red_delta = [0] * len(sample_part)
        blue_delta = [0] * len(sample_part)

        sample_part.sort(key=lambda x: order_f(x))
        angles = [order_f(p) for p in sample_part]
        try:
            l1 = to_line(p_0, sample_part[0])
            for p_1, w in zip(red_points, red_weights):

                insertion_pt = bisect.bisect_right(angles, order_f(p_1)) - 1
                if insertion_pt == -1:
                    pass
                elif l1.pt_eq_below_exact(p_1):
                    red_delta[insertion_pt] += -w
                else:
                    red_delta[insertion_pt] += w

            for p_1, w in zip(blue_points, blue_weights):
                insertion_pt = bisect.bisect_right(angles, order_f(p_1)) - 1
                if insertion_pt == -1:
                    pass
                elif l1.pt_eq_below_exact(p_1):
                    blue_delta[insertion_pt] += -w
                else:
                    blue_delta[insertion_pt] += w

            red_curr = sum(w for p, w in zip(red_points, red_weights)
                           if l1.pt_eq_below_exact(p))
            blue_curr = sum(w for p, w in zip(blue_points, blue_weights)
                            if l1.pt_eq_below_exact(p))
            # red_curr += red_delta[0]
            # blue_curr += blue_delta[0]
            for db, ds, p_1 in zip(red_delta, blue_delta, sample_part):

                if max_discrepancy <= disc(red_curr * a, blue_curr * b):
                    max_line = to_line(p_0, p_1)
                    max_discrepancy = disc(red_curr * a, blue_curr * b)
                red_curr += db
                blue_curr += ds
        except ZeroDivisionError:
            continue

    return max_discrepancy, max_line