@logic-pad/core 0.26.3 → 0.27.0

package/assets/logic-core.global.d.ts

@@ -2135,7 +2135,6 @@ declare global {
     withColor(color: Color): this;
     withCount(count: number): this;
     withComparison(comparison: Comparison): this;
-    private static countAllSymbolsOfPosition;
   }
   export declare class UniqueShapeRule extends RegionShapeRule {
     readonly title = 'Unique Shape Areas';
@@ -2538,7 +2537,7 @@ declare global {
   }
   export declare class SymbolsPerRegionBTModule extends BTModule {
     instr: SymbolsPerRegionRule;
-    private symbolCount;
+    private symbolMap;
     constructor(
       instr: SymbolsPerRegionRule,
       width: number,

package/dist/benchmark/helper.d.ts

@@ -18,4 +18,5 @@ export interface BenchmarkEntry {
     solveCorrect: boolean;
 }
 export declare function parseLink(link: string): Promise<Puzzle>;
+export declare function shuffleArray<T>(array: T[]): T[];
 export {};

package/dist/benchmark/helper.js

@@ -32,3 +32,15 @@ export async function parseLink(link) {
     }
     return Serializer.parsePuzzle(await bunCompressor.decompress(data));
 }
+export function shuffleArray(array) {
+    let currentIndex = array.length;
+    while (currentIndex !== 0) {
+        const randomIndex = Math.floor(Math.random() * currentIndex);
+        currentIndex--;
+        [array[currentIndex], array[randomIndex]] = [
+            array[randomIndex],
+            array[currentIndex],
+        ];
+    }
+    return array;
+}

package/dist/benchmark/prepareBench.js

@@ -1,11 +1,18 @@
 import { parseArgs } from 'util';
 import { allSolvers } from '../src/data/solver/allSolvers.js';
-import { parseLink } from './helper.js';
+import { parseLink, shuffleArray, } from './helper.js';
 import PQueue from 'p-queue';
-const allPuzzlesPath = 'benchmark/data/all_puzzles_logic_pad.json';
 const { values, positionals } = parseArgs({
     args: Bun.argv,
     options: {
+        name: {
+            type: 'string',
+            short: 'n',
+        },
+        file: {
+            type: 'string',
+            short: 'f',
+        },
         maxTime: {
             type: 'string',
             default: '10',
@@ -13,13 +20,13 @@ const { values, positionals } = parseArgs({
         },
         maxCount: {
             type: 'string',
-            default: '99999',
+            default: '200',
             short: 'c',
         },
         concurrency: {
             type: 'string',
             default: '4',
-            short: 'n',
+            short: 'd',
         },
         help: {
             type: 'boolean',
@@ -30,14 +37,17 @@ const { values, positionals } = parseArgs({
     allowPositionals: true,
 });
 positionals.splice(0, 2); // Remove "bun" and script name
-if (values.help || positionals.length !== 1) {
+if (values.help || positionals.length !== 1 || !values.file) {
     console.log(`
 Usage: bun bench:prepare <solver> [options]
 
 Options:
+  -f, --file <string>         Path to the puzzle data file (required)
+
+  -n, --name <string>         Name of the generated benchmark files (default: solver name)
   -t, --maxTime <number>      Maximum seconds allowed for each solve (default: 10)
   -c, --maxCount <number>     Maximum number of puzzles included (default: 100)
-  -n, --concurrency <number>  Number of solves to run concurrently (default: 4)
+  -d, --concurrency <number>  Number of solves to run concurrently (default: 4)
   -h, --help                  Show this help message
 
 Solver:
@@ -49,31 +59,36 @@ ${[...allSolvers.keys()].map(s => `    - ${s}`).join('\n')}
 const maxTime = parseFloat(values.maxTime) * 1000;
 const maxCount = parseInt(values.maxCount);
 const solverName = positionals[0];
+const outputName = values.name ?? solverName;
+const allPuzzlesPath = `benchmark/data/${values.file}`;
 const solver = allSolvers.get(solverName);
 if (!solver) {
     console.error(`Error: Solver "${solverName}" not found.`);
     process.exit(1);
 }
 const allPuzzles = (await Bun.file(allPuzzlesPath).json());
-allPuzzles.sort(() => Math.random() - 0.5);
+shuffleArray(allPuzzles);
 const results = [];
 const pqueue = new PQueue({ concurrency: 4 });
-function printEntry(benchmarkEntry, entryId, solverId, pid) {
+pqueue.on('completed', () => {
+    if (results.filter(r => r.result.solveCorrect && r.result.supported).length >=
+        maxCount) {
+        pqueue.clear();
+    }
+});
+function printEntry(benchmarkEntry, entryId, pid) {
+    const selectedPuzzles = results.filter(r => r.result.solveCorrect && r.result.supported);
     if (benchmarkEntry.supported) {
-        console.log(`${solverId}\t| ${entryId} / ${allPuzzles.length}\t| ${pid}\t| ${Number.isNaN(benchmarkEntry.solveTime)
+        console.log(`${entryId} / ${allPuzzles.length}    \t| ${selectedPuzzles.length} / ${maxCount}    \t| ${pid}\t| ${Number.isNaN(benchmarkEntry.solveTime)
             ? 'timeout'
             : `${benchmarkEntry.solveTime.toFixed(0)}ms`} ${benchmarkEntry.solveCorrect ? '✓' : '✗'}`);
     }
     else {
-        console.log(`${solverId}\t| ${entryId} / ${allPuzzles.length}\t| ${pid}\t| unsupported`);
+        console.log(`${entryId} / ${allPuzzles.length}    \t| ${selectedPuzzles.length} / ${maxCount}    \t| ${pid}\t| unsupported`);
     }
 }
 console.log('Available\t| Selected\t| PID\t| Result');
 for (const entry of allPuzzles) {
-    if (results.filter(r => r.result.solveCorrect && r.result.supported).length >=
-        maxCount) {
-        break;
-    }
     const puzzle = await parseLink(entry.puzzleLink);
     void pqueue.add(async () => {
         if (!solver.isGridSupported(puzzle.grid)) {
@@ -86,7 +101,7 @@ for (const entry of allPuzzles) {
                     solveCorrect: false,
                 },
             });
-            printEntry(results[results.length - 1].result, results.length, solverName, entry.pid);
+            printEntry(results[results.length - 1].result, results.length, entry.pid);
             return;
         }
         const startTime = performance.now();
@@ -122,19 +137,18 @@ for (const entry of allPuzzles) {
         }
         clearTimeout(handle);
         results.push({ puzzle: entry, result: benchmarkEntry });
-        printEntry(results[results.length - 1].result, results.length, solverName, entry.pid);
+        printEntry(results[results.length - 1].result, results.length, entry.pid);
     });
 }
 await pqueue.onIdle();
 const selectedPuzzles = results.filter(r => r.result.solveCorrect && r.result.supported);
 const benchmarkEntries = selectedPuzzles.map(r => r.result);
-await Bun.write(`benchmark/data/bench_${solverName}_puzzles.json`, JSON.stringify(selectedPuzzles.map(r => r.puzzle), null, 2));
-await Bun.write(`benchmark/data/bench_${solverName}_results.json`, JSON.stringify(benchmarkEntries, null, 2));
+await Bun.write(`benchmark/data/${outputName}_bench_puzzles.json`, JSON.stringify(selectedPuzzles.map(r => r.puzzle), null, 2));
+await Bun.write(`benchmark/data/${outputName}_bench_results.json`, JSON.stringify(benchmarkEntries, null, 2));
 console.log(`
 Benchmark preparation completed. Selected ${selectedPuzzles.length} puzzles.
 
 - Solver: ${solverName}   Max Time: ${maxTime}ms   Max Count: ${maxCount}
-- Average time: ${benchmarkEntries.filter(e => !Number.isNaN(e.solveTime)).reduce((a, b) => a + b.solveTime, 0) / benchmarkEntries.filter(e => !Number.isNaN(e.solveTime)).length}ms
-- Number of timeouts: ${benchmarkEntries.filter(e => Number.isNaN(e.solveTime)).length}
+- Average time: ${selectedPuzzles.reduce((a, b) => a + b.result.solveTime, 0) / selectedPuzzles.length}ms
 - Solve correctness: ${benchmarkEntries.filter(e => e.solveCorrect).length} / ${benchmarkEntries.length}
 `);

package/dist/benchmark/runBench.js

@@ -1,10 +1,14 @@
 import { parseArgs } from 'util';
 import { allSolvers } from '../src/data/solver/allSolvers.js';
-import { parseLink } from './helper.js';
+import { parseLink, shuffleArray, } from './helper.js';
 import PQueue from 'p-queue';
 const { values, positionals } = parseArgs({
     args: Bun.argv,
     options: {
+        name: {
+            type: 'string',
+            short: 'n',
+        },
         maxTime: {
             type: 'string',
             default: '10',
@@ -12,13 +16,13 @@ const { values, positionals } = parseArgs({
         },
         maxCount: {
             type: 'string',
-            default: '99999',
+            default: '200',
             short: 'c',
         },
         concurrency: {
             type: 'string',
             default: '4',
-            short: 'n',
+            short: 'd',
         },
         help: {
             type: 'boolean',
@@ -34,10 +38,11 @@ if (values.help || positionals.length === 0) {
 Usage: bun bench:run <solver> [options]
 
 Options:
-  -t, --maxTime <number>       Maximum seconds allowed for each solve (default: 10)
-  -c, --maxCount <number>      Maximum number of puzzles included (default: 100)
-  -n, --concurrency <number>   Number of solves to run concurrently (default: 4)
-  -h, --help                   Show this help message
+  -n, --name <string>         Name of the generated benchmark files (default: first solver name)
+  -t, --maxTime <number>      Maximum seconds allowed for each solve (default: 10)
+  -c, --maxCount <number>     Maximum number of puzzles included (default: 100)
+  -n, --concurrency <number>  Number of solves to run concurrently (default: 4)
+  -h, --help                  Show this help message
 
 Solvers available for benchmarking:
 ${[...allSolvers.keys()].map(s => `    - ${s}`).join('\n')}
@@ -53,8 +58,9 @@ for (const name of positionals) {
         process.exit(1);
     }
 }
-const allPuzzles = (await Bun.file(`benchmark/data/bench_${positionals[0]}_puzzles.json`).json());
-allPuzzles.sort(() => Math.random() - 0.5);
+const outputName = values.name ?? positionals[0];
+const allPuzzles = (await Bun.file(`benchmark/data/${outputName}_bench_puzzles.json`).json());
+shuffleArray(allPuzzles);
 allPuzzles.splice(maxCount);
 const benchmarkEntries = Object.fromEntries(positionals.map(name => [
     name,
@@ -139,9 +145,11 @@ const results = positionals.map(name => ({
     solve25: 0,
     solve50: 0,
     solve75: 0,
+    solve90: 0,
     solveSD: 0,
     unsupportedCount: 0,
     incorrectCount: 0,
+    timeoutCount: 0,
 }));
 for (let i = 0; i < benchmarkEntries[positionals[0]].length; i++) {
     let fastestSolveTime = Number.POSITIVE_INFINITY;
@@ -158,9 +166,12 @@ for (let i = 0; i < benchmarkEntries[positionals[0]].length; i++) {
                 fastestSolverIndex = j;
             }
         }
-        else {
+        else if (!Number.isNaN(entry.solveTime)) {
             results[j].incorrectCount++;
         }
+        else {
+            results[j].timeoutCount++;
+        }
     }
     if (fastestSolverIndex !== null) {
         results[fastestSolverIndex].fastestCount++;
@@ -184,6 +195,11 @@ for (let j = 0; j < positionals.length; j++) {
         times.length === 0
             ? Number.NaN
             : times[Math.floor((times.length - 1) * 0.75)];
+    // 90th percentile
+    results[j].solve90 =
+        times.length === 0
+            ? Number.NaN
+            : times[Math.floor((times.length - 1) * 0.9)];
     // Standard deviation
     const mean = times.reduce((sum, time) => sum + time, 0) / (times.length || 1);
     const variance = times.reduce((sum, time) => sum + (time - mean) ** 2, 0) /
@@ -199,8 +215,10 @@ ${result.solver}:
     P25: ${Number.isNaN(result.solve25) ? 'N/A' : `${result.solve25.toFixed(2)}ms`}
     P50: ${Number.isNaN(result.solve50) ? 'N/A' : `${result.solve50.toFixed(2)}ms`}
     P75: ${Number.isNaN(result.solve75) ? 'N/A' : `${result.solve75.toFixed(2)}ms`}
+    P90: ${Number.isNaN(result.solve90) ? 'N/A' : `${result.solve90.toFixed(2)}ms`}
     SD:  ${Number.isNaN(result.solveSD) ? 'N/A' : `${result.solveSD.toFixed(2)}ms`}
   Unsupported Puzzles: ${result.unsupportedCount}
   Incorrect Solutions: ${result.incorrectCount}
+  Timeouts:            ${result.timeoutCount}
 `);
 }

package/dist/src/data/rules/symbolsPerRegionRule.d.ts

@@ -33,6 +33,5 @@ export default class SymbolsPerRegionRule extends Rule {
     withColor(color: Color): this;
     withCount(count: number): this;
     withComparison(comparison: Comparison): this;
-    private static countAllSymbolsOfPosition;
 }
 export declare const instance: SymbolsPerRegionRule;

package/dist/src/data/rules/symbolsPerRegionRule.js

@@ -125,12 +125,24 @@ export default class SymbolsPerRegionRule extends Rule {
                 break;
             const completed = [];
             const gray = [];
+            const map = array(grid.width, grid.height, () => false);
             let nbSymbolsIn = 0;
             grid.iterateArea({ x: seed.x, y: seed.y }, tile => tile.color === this.color, (_, x, y) => {
                 completed.push({ x, y });
                 visited[y][x] = true;
-                nbSymbolsIn += SymbolsPerRegionRule.countAllSymbolsOfPosition(grid, x, y);
-            });
+            }, map);
+            for (const [_, symbols] of grid.symbols) {
+                for (const symbol of symbols) {
+                    if (!symbol.necessaryForCompletion)
+                        continue;
+                    if (map[Math.floor(symbol.y)][Math.floor(symbol.x)] ||
+                        map[Math.floor(symbol.y)][Math.ceil(symbol.x)] ||
+                        map[Math.ceil(symbol.y)][Math.floor(symbol.x)] ||
+                        map[Math.ceil(symbol.y)][Math.ceil(symbol.x)]) {
+                        nbSymbolsIn++;
+                    }
+                }
+            }
             if (this.comparison !== Comparison.AtLeast && nbSymbolsIn > this.count) {
                 return { state: State.Error, positions: completed };
             }
@@ -142,8 +154,20 @@ export default class SymbolsPerRegionRule extends Rule {
             else {
                 grid.iterateArea({ x: seed.x, y: seed.y }, tile => tile.color === Color.Gray || tile.color === this.color, (_, x, y) => {
                     gray.push({ x, y });
-                    nbSymbolsOut += SymbolsPerRegionRule.countAllSymbolsOfPosition(grid, x, y);
+                    map[y][x] = true;
                 });
+                for (const [_, symbols] of grid.symbols) {
+                    for (const symbol of symbols) {
+                        if (!symbol.necessaryForCompletion)
+                            continue;
+                        if (map[Math.floor(symbol.y)][Math.floor(symbol.x)] ||
+                            map[Math.floor(symbol.y)][Math.ceil(symbol.x)] ||
+                            map[Math.ceil(symbol.y)][Math.floor(symbol.x)] ||
+                            map[Math.ceil(symbol.y)][Math.ceil(symbol.x)]) {
+                            nbSymbolsOut++;
+                        }
+                    }
+                }
             }
             if (this.comparison !== Comparison.AtMost && nbSymbolsOut < this.count) {
                 return { state: State.Error, positions: gray };
@@ -166,16 +190,5 @@ export default class SymbolsPerRegionRule extends Rule {
     withComparison(comparison) {
         return this.copyWith({ comparison });
     }
-    static countAllSymbolsOfPosition(grid, x, y) {
-        let count = 0;
-        for (const symbolKind of grid.symbols.values()) {
-            if (symbolKind.some(symbol => Math.floor(symbol.x) === x &&
-                Math.floor(symbol.y) === y &&
-                symbol.necessaryForCompletion)) {
-                count++;
-            }
-        }
-        return count;
-    }
 }
 export const instance = new SymbolsPerRegionRule(Color.Dark, 1);

package/dist/src/data/solver/backtrack/rules/symbolsPerRegion.d.ts

@@ -3,7 +3,7 @@ import Symbol from '../../../symbols/symbol.js';
 import BTModule, { BTGridData, CheckResult } from '../data.js';
 export default class SymbolsPerRegionBTModule extends BTModule {
     instr: SymbolsPerRegionRule;
-    private symbolCount;
+    private symbolMap;
     constructor(instr: SymbolsPerRegionRule, width: number, height: number, allSymbols: Symbol[]);
     checkGlobal(grid: BTGridData): CheckResult | false;
     private visitArea;

package/dist/src/data/solver/backtrack/rules/symbolsPerRegion.js

@@ -1,16 +1,33 @@
+import { array } from '../../../dataHelper.js';
 import { Comparison } from '../../../primitives.js';
 import BTModule, { BTTile, IntArray2D, colorToBTTile, } from '../data.js';
 export default class SymbolsPerRegionBTModule extends BTModule {
     instr;
-    symbolCount;
+    symbolMap = [];
     constructor(instr, width, height, allSymbols) {
         super();
         this.instr = instr;
-        this.symbolCount = IntArray2D.create(width, height);
+        this.symbolMap = array(width, height, () => []);
         for (const symbol of allSymbols) {
-            const symbolX = Math.floor(symbol.x);
-            const symbolY = Math.floor(symbol.y);
-            this.symbolCount.set(symbolX, symbolY, this.symbolCount.get(symbolX, symbolY) + 1);
+            if (Math.floor(symbol.x) >= 0 && Math.floor(symbol.y) >= 0) {
+                this.symbolMap[Math.floor(symbol.y)][Math.floor(symbol.x)].push(symbol);
+            }
+            if (Math.ceil(symbol.x) !== Math.floor(symbol.x) &&
+                Math.ceil(symbol.x) < width &&
+                Math.floor(symbol.y) >= 0) {
+                this.symbolMap[Math.floor(symbol.y)][Math.ceil(symbol.x)].push(symbol);
+            }
+            if (Math.ceil(symbol.y) !== Math.floor(symbol.y) &&
+                Math.floor(symbol.x) >= 0 &&
+                Math.ceil(symbol.y) < height) {
+                this.symbolMap[Math.ceil(symbol.y)][Math.floor(symbol.x)].push(symbol);
+            }
+            if (Math.ceil(symbol.x) !== Math.floor(symbol.x) &&
+                Math.ceil(symbol.y) !== Math.floor(symbol.y) &&
+                Math.ceil(symbol.x) < width &&
+                Math.ceil(symbol.y) < height) {
+                this.symbolMap[Math.ceil(symbol.y)][Math.ceil(symbol.x)].push(symbol);
+            }
         }
     }
     checkGlobal(grid) {
@@ -35,13 +52,13 @@ export default class SymbolsPerRegionBTModule extends BTModule {
     visitArea(grid, tile, visited, pos, id) {
         const sameTileQueue = [pos];
         const usableTileQueue = [];
-        let completed = 0;
-        let possible = 0;
+        const completed = new Set();
+        const possible = new Set();
         visited.set(pos.x, pos.y, id);
         // Count same tile
         while (sameTileQueue.length > 0) {
             const curPos = sameTileQueue.pop();
-            completed += this.symbolCount.get(curPos.x, curPos.y);
+            this.symbolMap[curPos.y][curPos.x].forEach(symbol => completed.add(symbol));
             for (const edge of grid.getEdges(curPos)) {
                 if ((visited.get(edge.x, edge.y) & 0b01111111) === id)
                     continue;
@@ -56,7 +73,7 @@ export default class SymbolsPerRegionBTModule extends BTModule {
                 }
             }
         }
-        if (completed > this.instr.count) {
+        if (completed.size > this.instr.count) {
             return this.instr.comparison === Comparison.AtLeast;
         }
         if (this.instr.comparison === Comparison.AtMost)
@@ -64,8 +81,11 @@ export default class SymbolsPerRegionBTModule extends BTModule {
         // Count usable tile
         while (usableTileQueue.length > 0) {
             const curPos = usableTileQueue.pop();
-            possible += this.symbolCount.get(curPos.x, curPos.y);
-            if (completed + possible >= this.instr.count)
+            this.symbolMap[curPos.y][curPos.x].forEach(symbol => {
+                if (!completed.has(symbol))
+                    possible.add(symbol);
+            });
+            if (completed.size + possible.size >= this.instr.count)
                 return true;
             for (const edge of grid.getEdges(curPos)) {
                 if ((visited.get(edge.x, edge.y) & 0b01111111) === id)
@@ -77,6 +97,6 @@ export default class SymbolsPerRegionBTModule extends BTModule {
                 }
             }
         }
-        return completed + possible >= this.instr.count;
+        return completed.size + possible.size >= this.instr.count;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logic-pad/core",
-  "version": "0.26.3",
+  "version": "0.27.0",
   "type": "module",
   "files": [
     "dist",
@@ -48,6 +48,8 @@
     "typegen": "bun ./scripts/genTypes.ts",
     "bench:prepare": "bun ./benchmark/prepareBench.ts",
     "bench:run": "bun ./benchmark/runBench.ts",
+    "bench:prepare:lp": "bun bench:prepare universal -f all_puzzles_logic_pad.json -n lp",
+    "bench:run:lp": "bun bench:run universal universal_dev -n lp",
     "prepublishOnly": "bun run build"
   },
   "engines": {