Uploaded using `kernel-builder`.

Browse files

Files changed (12) hide show

build/torch211-cxx11-cpu-aarch64-linux/__init__.py +101 -3
build/torch211-cxx11-cpu-aarch64-linux/_ops.py +3 -3
build/torch211-cxx11-cpu-aarch64-linux/{_physarum_cpu_9dfad7c_dirty.abi3.so → _physarum_cpu_a57b48e.abi3.so} +2 -2
build/torch211-cxx11-cpu-aarch64-linux/metadata.json +6 -6
build/torch212-cxx11-cpu-aarch64-linux/__init__.py +101 -3
build/torch212-cxx11-cpu-aarch64-linux/_ops.py +3 -3
build/torch212-cxx11-cpu-aarch64-linux/{_physarum_cpu_9dfad7c_dirty.abi3.so → _physarum_cpu_a57b48e.abi3.so} +2 -2
build/torch212-cxx11-cpu-aarch64-linux/metadata.json +6 -6
build/torch213-cxx11-cpu-aarch64-linux/__init__.py +101 -3
build/torch213-cxx11-cpu-aarch64-linux/_ops.py +3 -3
build/torch213-cxx11-cpu-aarch64-linux/{_physarum_cpu_9dfad7c_dirty.abi3.so → _physarum_cpu_a57b48e.abi3.so} +2 -2
build/torch213-cxx11-cpu-aarch64-linux/metadata.json +6 -6

build/torch211-cxx11-cpu-aarch64-linux/__init__.py CHANGED Viewed

@@ -3,8 +3,10 @@
 Agents diffuse a chemoattractant trail and steer up its gradient; the emergent
 network is the same structure a real slime mould forms solving a maze. The
 agent step (three sensor look-ups, steering, motion, deposition) and the trail
-diffusion are vectorised with NEON on aarch64 and fall back to portable scalar
-elsewhere. The trail is an ordinary CPU tensor you read and render each step.
     from kernels import get_kernel
     physarum = get_kernel("phanerozoic/physarum", version=1, trust_remote_code=True)
@@ -80,4 +82,100 @@ class Physarum:
         return (rgb * 255 + 0.5).to(torch.uint8)
-__all__ = ["Physarum"]

 Agents diffuse a chemoattractant trail and steer up its gradient; the emergent
 network is the same structure a real slime mould forms solving a maze. The
 agent step (three sensor look-ups, steering, motion, deposition) and the trail
+diffusion vectorise with NEON on aarch64; the agent step is threaded across
+cores (set torch.set_num_threads) and works on tile-sorted agents for cache
+locality, with a portable scalar fallback. The trail is an ordinary CPU tensor
+you read and render each step.
     from kernels import get_kernel
     physarum = get_kernel("phanerozoic/physarum", version=1, trust_remote_code=True)
         return (rgb * 255 + 0.5).to(torch.uint8)
+def _bfs(net, a, b):
+    """Shortest 4-connected path a->b through the boolean grid `net`, or None."""
+    import collections
+    H, W = net.shape; (ax, ay), (bx, by) = a, b
+    if not bool(net[ay, ax]) or not bool(net[by, bx]): return None
+    seen = torch.zeros(H, W, dtype=torch.bool); seen[ay, ax] = True
+    prev = {}; q = collections.deque([(ax, ay)])
+    while q:
+        x, y = q.popleft()
+        if (x, y) == (bx, by):
+            p = [(x, y)]
+            while (x, y) != (ax, ay): x, y = prev[(x, y)]; p.append((x, y))
+            return p[::-1]
+        for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)):
+            nx, ny = x + dx, y + dy
+            if 0 <= nx < W and 0 <= ny < H and bool(net[ny, nx]) and not seen[ny, nx]:
+                seen[ny, nx] = True; prev[(nx, ny)] = (x, y); q.append((nx, ny))
+    return None
+class PhysarumFlow:
+    """Tero adaptive-conductivity Physarum solver on a masked grid.
+    Repeatedly solves the weighted-Laplacian flow between terminals (the flow_cg
+    kernel op) and reinforces high-flux edges; the conductivity field converges
+    onto the shortest path (one source/sink) or an efficient transport network
+    (several terminals). Edges live between 4-connected open cells.
+    Args:
+        open_mask: [H, W], nonzero = open cell, zero = wall.
+    """
+    def __init__(self, open_mask):
+        m = open_mask.to(torch.float32).contiguous()
+        self.m = m; self.H, self.W = m.shape
+        H, W = self.H, self.W
+        self.oE = torch.zeros(H, W); self.oE[:, :-1] = m[:, :-1] * m[:, 1:]   # open east edges
+        self.oS = torch.zeros(H, W); self.oS[:-1, :] = m[:-1, :] * m[1:, :]   # open south edges
+        self.cE = self.oE.clone().contiguous()
+        self.cS = self.oS.clone().contiguous()
+        self.p = torch.zeros(H, W).contiguous()
+    def solve(self, terminals, inject=None, iters=160, mu=1.3, dt=0.2,
+              floor=1e-3, cg_iters=120, cg_tol=1e-4):
+        """Run `iters` adaptation steps. terminals: list of (x, y). inject: net
+        current per terminal (defaults to source terminals[0], sinks the rest).
+        Returns self; read the network with .network()/.path()."""
+        H, W = self.H, self.W
+        if inject is None:
+            inject = [float(len(terminals) - 1)] + [-1.0] * (len(terminals) - 1)
+        b = torch.zeros(H, W)
+        for (tx, ty), v in zip(terminals, inject): b[ty, tx] += float(v)
+        b = b.contiguous()
+        gx, gy = terminals[-1]; ground = gy * W + gx                         # pin one terminal's gauge
+        for _ in range(int(iters)):
+            ops.flow_cg(self.cE, self.cS, b, self.p, ground, int(cg_iters), float(cg_tol))
+            Qe = torch.zeros(H, W); Qe[:, :-1] = (self.cE[:, :-1] * (self.p[:, :-1] - self.p[:, 1:])).abs()
+            Qs = torch.zeros(H, W); Qs[:-1, :] = (self.cS[:-1, :] * (self.p[:-1, :] - self.p[1:, :])).abs()
+            self.cE = torch.maximum(self.cE + dt * (Qe.pow(mu) - self.cE), floor * self.oE).mul_(self.oE).contiguous()
+            self.cS = torch.maximum(self.cS + dt * (Qs.pow(mu) - self.cS), floor * self.oS).mul_(self.oS).contiguous()
+        return self
+    def network(self, thresh=0.5):
+        """Boolean [H, W] mask of cells on high-conductivity edges."""
+        H, W = self.H, self.W
+        nn = torch.zeros(H, W, dtype=torch.bool)
+        e = self.cE > thresh; s = self.cS > thresh
+        nn[:, :-1] |= e[:, :-1]; nn[:, 1:] |= e[:, :-1]
+        nn[:-1, :] |= s[:-1, :]; nn[1:, :] |= s[:-1, :]
+        return nn & (self.m > 0)
+    def path(self, a, b, thresh=0.5):
+        """Shortest path (list of (x, y)) between two terminals through the
+        converged network, or None if they are not linked at `thresh`."""
+        return _bfs(self.network(thresh), a, b)
+def maze(height, width, seed=0):
+    """A recursive-division maze as a [H, W] float mask (1 = open, 0 = wall)."""
+    import random
+    rng = random.Random(seed); m = torch.ones(height, width)
+    m[0, :] = 0; m[-1, :] = 0; m[:, 0] = 0; m[:, -1] = 0
+    def div(x0, y0, x1, y1, dep):
+        if x1 - x0 < 6 or y1 - y0 < 6 or dep > 8: return
+        if (x1 - x0) > (y1 - y0):
+            wx = rng.randrange(x0 + 2, x1 - 1, 2); gy = rng.randrange(y0 + 1, y1, 2)
+            for y in range(y0, y1): m[y, wx] = 0
+            m[gy, wx] = 1; div(x0, y0, wx - 1, y1, dep + 1); div(wx + 1, y0, x1, y1, dep + 1)
+        else:
+            wy = rng.randrange(y0 + 2, y1 - 1, 2); gx = rng.randrange(x0 + 1, x1, 2)
+            for x in range(x0, x1): m[wy, x] = 0
+            m[wy, gx] = 1; div(x0, y0, x1, wy - 1, dep + 1); div(x0, wy + 1, x1, y1, dep + 1)
+    div(1, 1, width - 2, height - 2, 0)
+    return m
+__all__ = ["Physarum", "PhysarumFlow", "maze"]

build/torch211-cxx11-cpu-aarch64-linux/_ops.py CHANGED Viewed

@@ -1,9 +1,9 @@
 import torch
-from . import _physarum_cpu_9dfad7c_dirty
-ops = torch.ops._physarum_cpu_9dfad7c_dirty
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_physarum_cpu_9dfad7c_dirty::{op_name}"

 import torch
+from . import _physarum_cpu_a57b48e
+ops = torch.ops._physarum_cpu_a57b48e
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
+    return f"_physarum_cpu_a57b48e::{op_name}"

build/torch211-cxx11-cpu-aarch64-linux/{_physarum_cpu_9dfad7c_dirty.abi3.so → _physarum_cpu_a57b48e.abi3.so} RENAMED Viewed

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:789afdecb6b076eb834732fd618b0182e3f1c0e1e51ee5cf4e6b45e14eb8b3d9
-size 85120

 version https://git-lfs.github.com/spec/v1
+oid sha256:e3d694191dc96a1d7d915eb180e5230bcce9bb16f3b0f2de47b90747c350f28a
+size 153296

build/torch211-cxx11-cpu-aarch64-linux/metadata.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "physarum",
-  "id": "_physarum_cpu_9dfad7c_dirty",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
@@ -10,9 +10,9 @@
   "digest": {
     "algorithm": "sha256",
     "files": {
-      "__init__.py": "5wjltcYQACNQLyVO0SYLiz5g9Vy0o/qSogtd2z9YgE8=",
-      "_ops.py": "CdBM1t9Ra83HGXv7+a6poQnsfTXqg9cnwJFps4vQii0=",
-      "_physarum_cpu_9dfad7c_dirty.abi3.so": "eJr97LawduuDRzL9YYsBguPxwOHlHuXPTmtF4U64s9k=",
       "physarum/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
     }
   },
@@ -23,8 +23,8 @@
       "dirty": false
     },
     "kernel": {
-      "sha": "9dfad7c219a1c39f98eb5d05ccd2f566e90696fe",
-      "dirty": true
     }
   }
 }

 {
   "name": "physarum",
+  "id": "_physarum_cpu_a57b48e",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
   "digest": {
     "algorithm": "sha256",
     "files": {
+      "__init__.py": "q8Cp06QoKUiAkrc/bath8dVTdGnofXLiPVXcG1AvndQ=",
+      "_ops.py": "n6Gte2TrEwnD8qKlKIC3Xwk7CMXDuBFcDsymKGOqKlQ=",
+      "_physarum_cpu_a57b48e.abi3.so": "49aUGR3Jah19kV6xgOUjC8zpuxbzsPLeR7kHR8NQ8oo=",
       "physarum/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
     }
   },
       "dirty": false
     },
     "kernel": {
+      "sha": "a57b48e23004b429e1eca5517c5df547b8d1f8ac",
+      "dirty": false
     }
   }
 }

build/torch212-cxx11-cpu-aarch64-linux/__init__.py CHANGED Viewed

@@ -3,8 +3,10 @@
 Agents diffuse a chemoattractant trail and steer up its gradient; the emergent
 network is the same structure a real slime mould forms solving a maze. The
 agent step (three sensor look-ups, steering, motion, deposition) and the trail
-diffusion are vectorised with NEON on aarch64 and fall back to portable scalar
-elsewhere. The trail is an ordinary CPU tensor you read and render each step.
     from kernels import get_kernel
     physarum = get_kernel("phanerozoic/physarum", version=1, trust_remote_code=True)
@@ -80,4 +82,100 @@ class Physarum:
         return (rgb * 255 + 0.5).to(torch.uint8)
-__all__ = ["Physarum"]

 Agents diffuse a chemoattractant trail and steer up its gradient; the emergent
 network is the same structure a real slime mould forms solving a maze. The
 agent step (three sensor look-ups, steering, motion, deposition) and the trail
+diffusion vectorise with NEON on aarch64; the agent step is threaded across
+cores (set torch.set_num_threads) and works on tile-sorted agents for cache
+locality, with a portable scalar fallback. The trail is an ordinary CPU tensor
+you read and render each step.
     from kernels import get_kernel
     physarum = get_kernel("phanerozoic/physarum", version=1, trust_remote_code=True)
         return (rgb * 255 + 0.5).to(torch.uint8)
+def _bfs(net, a, b):
+    """Shortest 4-connected path a->b through the boolean grid `net`, or None."""
+    import collections
+    H, W = net.shape; (ax, ay), (bx, by) = a, b
+    if not bool(net[ay, ax]) or not bool(net[by, bx]): return None
+    seen = torch.zeros(H, W, dtype=torch.bool); seen[ay, ax] = True
+    prev = {}; q = collections.deque([(ax, ay)])
+    while q:
+        x, y = q.popleft()
+        if (x, y) == (bx, by):
+            p = [(x, y)]
+            while (x, y) != (ax, ay): x, y = prev[(x, y)]; p.append((x, y))
+            return p[::-1]
+        for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)):
+            nx, ny = x + dx, y + dy
+            if 0 <= nx < W and 0 <= ny < H and bool(net[ny, nx]) and not seen[ny, nx]:
+                seen[ny, nx] = True; prev[(nx, ny)] = (x, y); q.append((nx, ny))
+    return None
+class PhysarumFlow:
+    """Tero adaptive-conductivity Physarum solver on a masked grid.
+    Repeatedly solves the weighted-Laplacian flow between terminals (the flow_cg
+    kernel op) and reinforces high-flux edges; the conductivity field converges
+    onto the shortest path (one source/sink) or an efficient transport network
+    (several terminals). Edges live between 4-connected open cells.
+    Args:
+        open_mask: [H, W], nonzero = open cell, zero = wall.
+    """
+    def __init__(self, open_mask):
+        m = open_mask.to(torch.float32).contiguous()
+        self.m = m; self.H, self.W = m.shape
+        H, W = self.H, self.W
+        self.oE = torch.zeros(H, W); self.oE[:, :-1] = m[:, :-1] * m[:, 1:]   # open east edges
+        self.oS = torch.zeros(H, W); self.oS[:-1, :] = m[:-1, :] * m[1:, :]   # open south edges
+        self.cE = self.oE.clone().contiguous()
+        self.cS = self.oS.clone().contiguous()
+        self.p = torch.zeros(H, W).contiguous()
+    def solve(self, terminals, inject=None, iters=160, mu=1.3, dt=0.2,
+              floor=1e-3, cg_iters=120, cg_tol=1e-4):
+        """Run `iters` adaptation steps. terminals: list of (x, y). inject: net
+        current per terminal (defaults to source terminals[0], sinks the rest).
+        Returns self; read the network with .network()/.path()."""
+        H, W = self.H, self.W
+        if inject is None:
+            inject = [float(len(terminals) - 1)] + [-1.0] * (len(terminals) - 1)
+        b = torch.zeros(H, W)
+        for (tx, ty), v in zip(terminals, inject): b[ty, tx] += float(v)
+        b = b.contiguous()
+        gx, gy = terminals[-1]; ground = gy * W + gx                         # pin one terminal's gauge
+        for _ in range(int(iters)):
+            ops.flow_cg(self.cE, self.cS, b, self.p, ground, int(cg_iters), float(cg_tol))
+            Qe = torch.zeros(H, W); Qe[:, :-1] = (self.cE[:, :-1] * (self.p[:, :-1] - self.p[:, 1:])).abs()
+            Qs = torch.zeros(H, W); Qs[:-1, :] = (self.cS[:-1, :] * (self.p[:-1, :] - self.p[1:, :])).abs()
+            self.cE = torch.maximum(self.cE + dt * (Qe.pow(mu) - self.cE), floor * self.oE).mul_(self.oE).contiguous()
+            self.cS = torch.maximum(self.cS + dt * (Qs.pow(mu) - self.cS), floor * self.oS).mul_(self.oS).contiguous()
+        return self
+    def network(self, thresh=0.5):
+        """Boolean [H, W] mask of cells on high-conductivity edges."""
+        H, W = self.H, self.W
+        nn = torch.zeros(H, W, dtype=torch.bool)
+        e = self.cE > thresh; s = self.cS > thresh
+        nn[:, :-1] |= e[:, :-1]; nn[:, 1:] |= e[:, :-1]
+        nn[:-1, :] |= s[:-1, :]; nn[1:, :] |= s[:-1, :]
+        return nn & (self.m > 0)
+    def path(self, a, b, thresh=0.5):
+        """Shortest path (list of (x, y)) between two terminals through the
+        converged network, or None if they are not linked at `thresh`."""
+        return _bfs(self.network(thresh), a, b)
+def maze(height, width, seed=0):
+    """A recursive-division maze as a [H, W] float mask (1 = open, 0 = wall)."""
+    import random
+    rng = random.Random(seed); m = torch.ones(height, width)
+    m[0, :] = 0; m[-1, :] = 0; m[:, 0] = 0; m[:, -1] = 0
+    def div(x0, y0, x1, y1, dep):
+        if x1 - x0 < 6 or y1 - y0 < 6 or dep > 8: return
+        if (x1 - x0) > (y1 - y0):
+            wx = rng.randrange(x0 + 2, x1 - 1, 2); gy = rng.randrange(y0 + 1, y1, 2)
+            for y in range(y0, y1): m[y, wx] = 0
+            m[gy, wx] = 1; div(x0, y0, wx - 1, y1, dep + 1); div(wx + 1, y0, x1, y1, dep + 1)
+        else:
+            wy = rng.randrange(y0 + 2, y1 - 1, 2); gx = rng.randrange(x0 + 1, x1, 2)
+            for x in range(x0, x1): m[wy, x] = 0
+            m[wy, gx] = 1; div(x0, y0, x1, wy - 1, dep + 1); div(x0, wy + 1, x1, y1, dep + 1)
+    div(1, 1, width - 2, height - 2, 0)
+    return m
+__all__ = ["Physarum", "PhysarumFlow", "maze"]

build/torch212-cxx11-cpu-aarch64-linux/_ops.py CHANGED Viewed

@@ -1,9 +1,9 @@
 import torch
-from . import _physarum_cpu_9dfad7c_dirty
-ops = torch.ops._physarum_cpu_9dfad7c_dirty
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_physarum_cpu_9dfad7c_dirty::{op_name}"

 import torch
+from . import _physarum_cpu_a57b48e
+ops = torch.ops._physarum_cpu_a57b48e
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
+    return f"_physarum_cpu_a57b48e::{op_name}"

build/torch212-cxx11-cpu-aarch64-linux/{_physarum_cpu_9dfad7c_dirty.abi3.so → _physarum_cpu_a57b48e.abi3.so} RENAMED Viewed

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1e0a34e2de1b81efc70de4ecef7d5f32271aa5070a8d2c6ff7ada59f9f7d41d0
-size 85272

 version https://git-lfs.github.com/spec/v1
+oid sha256:17d57732072d4daac322799037b731a03bc7a1ea6ae602979c311d54692316cf
+size 153320

build/torch212-cxx11-cpu-aarch64-linux/metadata.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "physarum",
-  "id": "_physarum_cpu_9dfad7c_dirty",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
@@ -10,9 +10,9 @@
   "digest": {
     "algorithm": "sha256",
     "files": {
-      "__init__.py": "5wjltcYQACNQLyVO0SYLiz5g9Vy0o/qSogtd2z9YgE8=",
-      "_ops.py": "CdBM1t9Ra83HGXv7+a6poQnsfTXqg9cnwJFps4vQii0=",
-      "_physarum_cpu_9dfad7c_dirty.abi3.so": "Hgo04t4bge/HDeTs731fMicapQcKjSxv962ln599QdA=",
       "physarum/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
     }
   },
@@ -23,8 +23,8 @@
       "dirty": false
     },
     "kernel": {
-      "sha": "9dfad7c219a1c39f98eb5d05ccd2f566e90696fe",
-      "dirty": true
     }
   }
 }

 {
   "name": "physarum",
+  "id": "_physarum_cpu_a57b48e",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
   "digest": {
     "algorithm": "sha256",
     "files": {
+      "__init__.py": "q8Cp06QoKUiAkrc/bath8dVTdGnofXLiPVXcG1AvndQ=",
+      "_ops.py": "n6Gte2TrEwnD8qKlKIC3Xwk7CMXDuBFcDsymKGOqKlQ=",
+      "_physarum_cpu_a57b48e.abi3.so": "F9V3MgctTarDInmQN7cxoDvHoepq5gKXnDEdVGkjFs8=",
       "physarum/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
     }
   },
       "dirty": false
     },
     "kernel": {
+      "sha": "a57b48e23004b429e1eca5517c5df547b8d1f8ac",
+      "dirty": false
     }
   }
 }

build/torch213-cxx11-cpu-aarch64-linux/__init__.py CHANGED Viewed

@@ -3,8 +3,10 @@
 Agents diffuse a chemoattractant trail and steer up its gradient; the emergent
 network is the same structure a real slime mould forms solving a maze. The
 agent step (three sensor look-ups, steering, motion, deposition) and the trail
-diffusion are vectorised with NEON on aarch64 and fall back to portable scalar
-elsewhere. The trail is an ordinary CPU tensor you read and render each step.
     from kernels import get_kernel
     physarum = get_kernel("phanerozoic/physarum", version=1, trust_remote_code=True)
@@ -80,4 +82,100 @@ class Physarum:
         return (rgb * 255 + 0.5).to(torch.uint8)
-__all__ = ["Physarum"]

 Agents diffuse a chemoattractant trail and steer up its gradient; the emergent
 network is the same structure a real slime mould forms solving a maze. The
 agent step (three sensor look-ups, steering, motion, deposition) and the trail
+diffusion vectorise with NEON on aarch64; the agent step is threaded across
+cores (set torch.set_num_threads) and works on tile-sorted agents for cache
+locality, with a portable scalar fallback. The trail is an ordinary CPU tensor
+you read and render each step.
     from kernels import get_kernel
     physarum = get_kernel("phanerozoic/physarum", version=1, trust_remote_code=True)
         return (rgb * 255 + 0.5).to(torch.uint8)
+def _bfs(net, a, b):
+    """Shortest 4-connected path a->b through the boolean grid `net`, or None."""
+    import collections
+    H, W = net.shape; (ax, ay), (bx, by) = a, b
+    if not bool(net[ay, ax]) or not bool(net[by, bx]): return None
+    seen = torch.zeros(H, W, dtype=torch.bool); seen[ay, ax] = True
+    prev = {}; q = collections.deque([(ax, ay)])
+    while q:
+        x, y = q.popleft()
+        if (x, y) == (bx, by):
+            p = [(x, y)]
+            while (x, y) != (ax, ay): x, y = prev[(x, y)]; p.append((x, y))
+            return p[::-1]
+        for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)):
+            nx, ny = x + dx, y + dy
+            if 0 <= nx < W and 0 <= ny < H and bool(net[ny, nx]) and not seen[ny, nx]:
+                seen[ny, nx] = True; prev[(nx, ny)] = (x, y); q.append((nx, ny))
+    return None
+class PhysarumFlow:
+    """Tero adaptive-conductivity Physarum solver on a masked grid.
+    Repeatedly solves the weighted-Laplacian flow between terminals (the flow_cg
+    kernel op) and reinforces high-flux edges; the conductivity field converges
+    onto the shortest path (one source/sink) or an efficient transport network
+    (several terminals). Edges live between 4-connected open cells.
+    Args:
+        open_mask: [H, W], nonzero = open cell, zero = wall.
+    """
+    def __init__(self, open_mask):
+        m = open_mask.to(torch.float32).contiguous()
+        self.m = m; self.H, self.W = m.shape
+        H, W = self.H, self.W
+        self.oE = torch.zeros(H, W); self.oE[:, :-1] = m[:, :-1] * m[:, 1:]   # open east edges
+        self.oS = torch.zeros(H, W); self.oS[:-1, :] = m[:-1, :] * m[1:, :]   # open south edges
+        self.cE = self.oE.clone().contiguous()
+        self.cS = self.oS.clone().contiguous()
+        self.p = torch.zeros(H, W).contiguous()
+    def solve(self, terminals, inject=None, iters=160, mu=1.3, dt=0.2,
+              floor=1e-3, cg_iters=120, cg_tol=1e-4):
+        """Run `iters` adaptation steps. terminals: list of (x, y). inject: net
+        current per terminal (defaults to source terminals[0], sinks the rest).
+        Returns self; read the network with .network()/.path()."""
+        H, W = self.H, self.W
+        if inject is None:
+            inject = [float(len(terminals) - 1)] + [-1.0] * (len(terminals) - 1)
+        b = torch.zeros(H, W)
+        for (tx, ty), v in zip(terminals, inject): b[ty, tx] += float(v)
+        b = b.contiguous()
+        gx, gy = terminals[-1]; ground = gy * W + gx                         # pin one terminal's gauge
+        for _ in range(int(iters)):
+            ops.flow_cg(self.cE, self.cS, b, self.p, ground, int(cg_iters), float(cg_tol))
+            Qe = torch.zeros(H, W); Qe[:, :-1] = (self.cE[:, :-1] * (self.p[:, :-1] - self.p[:, 1:])).abs()
+            Qs = torch.zeros(H, W); Qs[:-1, :] = (self.cS[:-1, :] * (self.p[:-1, :] - self.p[1:, :])).abs()
+            self.cE = torch.maximum(self.cE + dt * (Qe.pow(mu) - self.cE), floor * self.oE).mul_(self.oE).contiguous()
+            self.cS = torch.maximum(self.cS + dt * (Qs.pow(mu) - self.cS), floor * self.oS).mul_(self.oS).contiguous()
+        return self
+    def network(self, thresh=0.5):
+        """Boolean [H, W] mask of cells on high-conductivity edges."""
+        H, W = self.H, self.W
+        nn = torch.zeros(H, W, dtype=torch.bool)
+        e = self.cE > thresh; s = self.cS > thresh
+        nn[:, :-1] |= e[:, :-1]; nn[:, 1:] |= e[:, :-1]
+        nn[:-1, :] |= s[:-1, :]; nn[1:, :] |= s[:-1, :]
+        return nn & (self.m > 0)
+    def path(self, a, b, thresh=0.5):
+        """Shortest path (list of (x, y)) between two terminals through the
+        converged network, or None if they are not linked at `thresh`."""
+        return _bfs(self.network(thresh), a, b)
+def maze(height, width, seed=0):
+    """A recursive-division maze as a [H, W] float mask (1 = open, 0 = wall)."""
+    import random
+    rng = random.Random(seed); m = torch.ones(height, width)
+    m[0, :] = 0; m[-1, :] = 0; m[:, 0] = 0; m[:, -1] = 0
+    def div(x0, y0, x1, y1, dep):
+        if x1 - x0 < 6 or y1 - y0 < 6 or dep > 8: return
+        if (x1 - x0) > (y1 - y0):
+            wx = rng.randrange(x0 + 2, x1 - 1, 2); gy = rng.randrange(y0 + 1, y1, 2)
+            for y in range(y0, y1): m[y, wx] = 0
+            m[gy, wx] = 1; div(x0, y0, wx - 1, y1, dep + 1); div(wx + 1, y0, x1, y1, dep + 1)
+        else:
+            wy = rng.randrange(y0 + 2, y1 - 1, 2); gx = rng.randrange(x0 + 1, x1, 2)
+            for x in range(x0, x1): m[wy, x] = 0
+            m[wy, gx] = 1; div(x0, y0, x1, wy - 1, dep + 1); div(x0, wy + 1, x1, y1, dep + 1)
+    div(1, 1, width - 2, height - 2, 0)
+    return m
+__all__ = ["Physarum", "PhysarumFlow", "maze"]

build/torch213-cxx11-cpu-aarch64-linux/_ops.py CHANGED Viewed

@@ -1,9 +1,9 @@
 import torch
-from . import _physarum_cpu_9dfad7c_dirty
-ops = torch.ops._physarum_cpu_9dfad7c_dirty
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_physarum_cpu_9dfad7c_dirty::{op_name}"

 import torch
+from . import _physarum_cpu_a57b48e
+ops = torch.ops._physarum_cpu_a57b48e
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
+    return f"_physarum_cpu_a57b48e::{op_name}"

build/torch213-cxx11-cpu-aarch64-linux/{_physarum_cpu_9dfad7c_dirty.abi3.so → _physarum_cpu_a57b48e.abi3.so} RENAMED Viewed

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:61a49d1e0cfb3223c73c0e34be651de8f6460b0b1a7fbad3429a6cd75c893002
-size 85272

 version https://git-lfs.github.com/spec/v1
+oid sha256:8f849a9e8e94bfb8f4bb1394c461c48fdfb7e2eb7b3cb809fe4a2ee92c825eb9
+size 153320

build/torch213-cxx11-cpu-aarch64-linux/metadata.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "physarum",
-  "id": "_physarum_cpu_9dfad7c_dirty",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
@@ -10,9 +10,9 @@
   "digest": {
     "algorithm": "sha256",
     "files": {
-      "__init__.py": "5wjltcYQACNQLyVO0SYLiz5g9Vy0o/qSogtd2z9YgE8=",
-      "_ops.py": "CdBM1t9Ra83HGXv7+a6poQnsfTXqg9cnwJFps4vQii0=",
-      "_physarum_cpu_9dfad7c_dirty.abi3.so": "YaSdHgz7MiPHPA40vmUd6PZGCwsaf7rTQpps11yJMAI=",
       "physarum/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
     }
   },
@@ -23,8 +23,8 @@
       "dirty": false
     },
     "kernel": {
-      "sha": "9dfad7c219a1c39f98eb5d05ccd2f566e90696fe",
-      "dirty": true
     }
   }
 }

 {
   "name": "physarum",
+  "id": "_physarum_cpu_a57b48e",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
   "digest": {
     "algorithm": "sha256",
     "files": {
+      "__init__.py": "q8Cp06QoKUiAkrc/bath8dVTdGnofXLiPVXcG1AvndQ=",
+      "_ops.py": "n6Gte2TrEwnD8qKlKIC3Xwk7CMXDuBFcDsymKGOqKlQ=",
+      "_physarum_cpu_a57b48e.abi3.so": "j4Sano6Uv7j0uxOUxGHEj9+34ut7PLgJ/kou6SyCXrk=",
       "physarum/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
     }
   },
       "dirty": false
     },
     "kernel": {
+      "sha": "a57b48e23004b429e1eca5517c5df547b8d1f8ac",
+      "dirty": false
     }
   }
 }