"""How much of each human training window works in our engine.""" import glob, random, sys, collections import numpy as np, torch import factorion_rs import corpus.convert as cv from build_tasks import records, MACH, SRC, SNK, BELTISH, SPLITTER, DELTA, C from compare import frame as bp_frame from factorion import Channel, Footprint, count_dangling_inserters, count_unpowered, refresh_power, str2ent, str2item INS = {str2ent(n).value for n in ("inserter", "long_handed_inserter")} rng = random.Random(0) c = collections.Counter() for rec in records(sorted(glob.glob(sys.argv[1]))): if c["windows"] >= int(sys.argv[2]): break if not rec.get("lanes"): continue bp = next(cv.designs(rec["string"])); bp["unbuildable"] = rec.get("unbuildable") or [] r = cv.rasterise(bp) if r is None: continue mx, my = bp_frame(bp) lab = {} for x, y, _, its in rec["lanes"]: lab.setdefault((x - mx, y - my), set()).update(i.replace("-", "_") for i in its.split(",")) f = cv.frame(r, 32, rng) w = None if f is None else cv.place(r, f, 32, region=True) if w is None: continue c["windows"] += 1 ent = w[Channel.ENTITIES.value] build = w[Channel.FOOTPRINT.value] == Footprint.BUILDABLE.value n_mach = len({tuple(p) for p in np.argwhere(np.isin(ent, list(MACH)))}) // 9 + 0 # approx (3x3 / 2x2 mix) c["inserters"] += int(np.isin(ent, list(INS)).sum()) d_in, d_out = count_dangling_inserters(torch.from_numpy(w)) c["inserters nothing feeds"] += d_in; c["inserters feeding nothing"] += d_out c["unpowered machines+inserters"] += count_unpowered(torch.from_numpy(w)) c["machine+inserter tiles in build region"] += int((build & np.isin(ent, list(MACH | INS))).sum()) # Flow test on the build region: sources/sinks where labelled belts cross its edge. x0, y0, bw, bh = f.x + f.bx, f.y + f.by, f.bw, f.bh inside = lambda x, y: x0 <= x < x0 + bw and y0 <= y < y0 + bh # noqa: E731 W, H = r.ent.shape g = np.zeros((len(Channel), bw + 2, bh + 2), np.int64) inst = r.inst[x0:x0 + bw, y0:y0 + bh] inner = np.bincount(inst[inst > 0], minlength=len(r.tiles)) whole = (inst > 0) & (inner == r.tiles)[np.maximum(inst, 0)] for (i, j) in np.argwhere(whole): for cc, a in zip(C, (r.ent, r.dir, r.item, r.misc)): g[cc, i + 1, j + 1] = a[x0 + i, y0 + j] g[Channel.FOOTPRINT.value] = Footprint.UNBUILDABLE.value n_src = n_snk = 0 for x in range(x0, x0 + bw): for y in range(y0, y0 + bh): if (x not in (x0, x0 + bw - 1) and y not in (y0, y0 + bh - 1)) or r.ent[x, y] not in BELTISH or int(r.dir[x, y]) not in DELTA: continue its = lab.get((x, y), set()) if len(its) != 1 or str2item(next(iter(its))) is None: continue dx, dy = DELTA[int(r.dir[x, y])] for (ux, uy), kind in (((x - dx, y - dy), SRC), ((x + dx, y + dy), SNK)): if not inside(ux, uy) and 0 <= ux < W and 0 <= uy < H and r.ent[ux, uy] in BELTISH | {SPLITTER}: gx, gy = ux - x0 + 1, uy - y0 + 1 if 0 <= gx < bw + 2 and 0 <= gy < bh + 2: g[C[0], gx, gy], g[C[1], gx, gy], g[C[2], gx, gy] = kind, int(r.dir[x, y]), str2item(next(iter(its))).value n_src += kind == SRC; n_snk += kind == SNK has_mach = np.isin(g[C[0]], list(MACH)).any() c["build regions with a machine"] += has_mach if n_src and n_snk: c["...with labelled sources and sinks"] += 1 refresh_power(torch.from_numpy(g)) thput = factorion_rs.simulate_throughput(np.ascontiguousarray(g.transpose(1, 2, 0)))[0] c["...that deliver anything"] += thput > 0 if has_mach: c["...with a machine, labelled ends"] += 1 bare = g.copy(); bare[:4, np.isin(bare[C[0]], list(MACH))] = 0 through = factorion_rs.simulate_throughput(np.ascontiguousarray(bare.transpose(1, 2, 0)))[0] c["...with a machine, and the machines add output"] += thput > through for k, v in c.items(): print(f"{k:50s} {v}")