dost

@@ -1,6 +1,7 @@

 import itertools

 import math

 import random

+import time

 import turtle

 import typing

 import collections.abc

@@ -66,6 +67,9 @@ def score_total(distances: DistTable, sample: IndSeq) -> float:

         0 if i in sample else distances[i][j] for j in sample

     ) for i in range(len(distances)))

+def score_spread(distances: DistTable, sample: IndSeq) -> float:

+    return -sum(sum(distances[sample[i]][j] for j in sample[:i]) for i in range(len(sample)))

+

 def greedy_min_seq(distances: DistTable, score_func: Func[[DistTable, IndSeq], float]) -> IndSeq:

     seq = []

     options = set(range(len(distances)))

@@ -116,24 +120,36 @@ def scattered_hierarchy(hierarchy: BinaryTree) -> IndSeq:

         seq.append(fb.a)

     return seq

-def with_len(distances: DistTable, seq: IndSeq):

-    return (sum(distances[i][j] for (i, j) in itertools.pairwise(seq)), seq)

+def total_len(distances: DistTable, seq: IndSeq) -> float:

+    return sum(distances[i][j] for (i, j) in itertools.pairwise(seq))

-points: list[tuple[float, float]] = [(random.randint(0, 10), random.randint(0, 10)) for _ in range(10)]

+N = 100

+points: list[tuple[float, float]] = [(random.randint(0, N // 2), random.randint(0, N // 3)) for _ in range(N)]

 print(points)

 t: turtle.Turtle = turtle.Turtle()

 t.hideturtle()

 t.pen(speed=10)

-for (i, (x, y)) in enumerate(points):

-    t.teleport(50 * (x - 5), 50 * (y - 5))

-    t.dot()

-    t.write(i)

 dt: DistTable = distance_table(points, math.dist)

 print(show_mat(dt))

 h: BinaryTree = distance_hierarchy(dt)

 print(h)

-print("by graph", with_len(dt, scattered_hierarchy(h)))

-print("by nearest-nb sum", with_len(dt, greedy_min_seq(dt, score_nearest)))

-print("by total dist", with_len(dt, greedy_min_seq(dt, score_total)))

-print("by furthest-nb", with_len(dt, furthest_nb(dt)))

-input("done?")

+METHODS = [

+    ("graph", lambda: scattered_hierarchy(h)),

+    ("nearest-nb sum", lambda: greedy_min_seq(dt, score_nearest)),

+    ("all dist sum", lambda: greedy_min_seq(dt, score_total)),

+    ("sample spread", lambda: greedy_min_seq(dt, score_spread)),

+    ("furthest-nb", lambda: furthest_nb(dt)),

+]

+input("ready?")

+for (name, method) in METHODS:

+    to = time.time()

+    seq = method()

+    tf = time.time()

+    l = total_len(dt, seq)

+    print(f"{name} method took {tf - to} s to find {seq}, length {l}")

+    t.clear()

+    for (i, (x, y)) in enumerate(points[k] for k in seq):

+        t.teleport(2000 / N * (x - 0.25 * N), 2000 / N * (y - 0.17 * N))

+        t.dot(20 / math.sqrt(i + 1))

+        t.write(i)

+    input("next?")