cubegin 0.0.1

package/dist/scramble-core/src/solvers/threephase/search.mjs

@@ -0,0 +1,262 @@
+import { SearchWCA } from "../min2phase/search-wca.mjs";
+import { ckmv2, ckmv3, move2std, move3std, skipAxis2, skipAxis3, toMove } from "./tables.mjs";
+import { Center1, Center2, Center3 } from "./center.mjs";
+import { Edge3 } from "./edge.mjs";
+import { FullCube } from "./full-cube.mjs";
+//#region .build/vendor/scramble-core/src/solvers/threephase/search.ts
+const PHASE1_SOLUTIONS = 1e4;
+const PHASE2_ATTEMPTS = 500;
+const PHASE2_SOLUTIONS = 100;
+const PHASE3_ATTEMPTS = 100;
+let isInitialized = false;
+const initThreephaseTables = () => {
+	if (isInitialized) return;
+	SearchWCA.init();
+	Center1.initSym();
+	Center1.raw2sym = Array.from({ length: 735471 }, () => 0);
+	Center1.initSym2Raw();
+	Center1.createMoveTable();
+	Center1.raw2sym = null;
+	Center1.createPrun();
+	Center2.init();
+	Center3.init();
+	Edge3.initMvrot();
+	Edge3.initRaw2Sym();
+	Edge3.createPrun();
+	isInitialized = true;
+};
+var Search = class {
+	inverseSolution = true;
+	withRotation = false;
+	solution = "";
+	p1sols = [];
+	move1 = Array.from({ length: 15 }, () => 0);
+	move2 = Array.from({ length: 20 }, () => 0);
+	move3 = Array.from({ length: 20 }, () => 0);
+	c1 = new FullCube();
+	c2 = new FullCube();
+	ct2 = new Center2();
+	ct3 = new Center3();
+	e12 = new Edge3();
+	tempe = Array.from({ length: 20 }, () => new Edge3());
+	search333 = new SearchWCA();
+	arr2 = Array.from({ length: PHASE2_SOLUTIONS }, () => null);
+	cube = new FullCube();
+	length1 = 0;
+	length2 = 0;
+	add1 = false;
+	p1SolsCnt = 0;
+	arr2idx = 0;
+	randomState(random) {
+		this.cube = FullCube.random(random);
+		this.doSearch();
+		return this.solution;
+	}
+	solve(scramble) {
+		this.cube = FullCube.fromMoves(scramble);
+		this.doSearch();
+		return this.solution;
+	}
+	doSearch() {
+		initThreephaseTables();
+		this.solution = "";
+		const ud = new Center1(this.cube.getCenter(), 0).getsym();
+		const fb = new Center1(this.cube.getCenter(), 1).getsym();
+		const rl = new Center1(this.cube.getCenter(), 2).getsym();
+		const udprun = Center1.csprun[ud >>> 6];
+		const fbprun = Center1.csprun[fb >>> 6];
+		const rlprun = Center1.csprun[rl >>> 6];
+		this.p1SolsCnt = 0;
+		this.arr2idx = 0;
+		this.p1sols.length = 0;
+		for (this.length1 = Math.min(udprun, fbprun, rlprun); this.length1 < 100; this.length1 += 1) if (rlprun <= this.length1 && this.search1(rl >>> 6, rl & 63, this.length1, -1, 0) || udprun <= this.length1 && this.search1(ud >>> 6, ud & 63, this.length1, -1, 0) || fbprun <= this.length1 && this.search1(fb >>> 6, fb & 63, this.length1, -1, 0)) break;
+		const p1SolsArr = [...this.p1sols].sort((first, second) => first.value - second.value);
+		if (p1SolsArr[0] === void 0) throw new Error("@cubegin/scramble-core: threephase phase 1 found no candidates");
+		let maxLength2 = 9;
+		let length12 = 100;
+		do {
+			outer: for (length12 = p1SolsArr[0].value; length12 < 100; length12 += 1) for (const p1Solution of p1SolsArr) {
+				if (p1Solution.value > length12) break;
+				if (length12 - p1Solution.length1 > maxLength2) continue;
+				this.c1.copy(p1Solution);
+				this.ct2.set(this.c1.getCenter(), this.c1.getEdge().getParity());
+				const s2ct = this.ct2.getct();
+				const s2rl = this.ct2.getrl();
+				this.length1 = p1Solution.length1;
+				this.length2 = length12 - p1Solution.length1;
+				if (this.search2(s2ct, s2rl, this.length2, 28, 0)) break outer;
+			}
+			maxLength2 += 1;
+		} while (length12 === 100);
+		const arr2 = this.arr2.slice(0, this.arr2idx).filter((cube) => cube !== null).sort((first, second) => first.value - second.value);
+		if (arr2.length === 0) throw new Error(`@cubegin/scramble-core: threephase phase 2 found no candidates (phase1=${this.p1sols.length}, firstValue=${String(p1SolsArr[0]?.value)}, arr2idx=${this.arr2idx}, arr2len=${this.arr2.length})`);
+		let length123 = 100;
+		let index = 0;
+		let maxLength3 = 13;
+		do {
+			outer2: for (length123 = arr2[0].value; length123 < 100; length123 += 1) for (let i = 0; i < Math.min(arr2.length, PHASE3_ATTEMPTS); i += 1) {
+				const candidate = arr2[i];
+				if (candidate.value > length123) break;
+				if (length123 - candidate.length1 - candidate.length2 > maxLength3) continue;
+				const edgeParity = this.e12.setFromEdgeCube(candidate.getEdge());
+				this.ct3.set(candidate.getCenter(), edgeParity ^ candidate.getCorner().getParity());
+				const ct = this.ct3.getct();
+				const edge = this.e12.get(10);
+				const prun = Edge3.getprun(this.e12.getsym());
+				const length3 = length123 - candidate.length1 - candidate.length2;
+				if (prun <= length3 && this.search3(edge, ct, prun, length3, 20, 0)) {
+					index = i;
+					break outer2;
+				}
+			}
+			maxLength3 += 1;
+		} while (length123 === 100);
+		const solcube = new FullCube(arr2[index]);
+		this.length1 = solcube.length1;
+		this.length2 = solcube.length2;
+		const length = length123 - this.length1 - this.length2;
+		for (let i = 0; i < length; i += 1) solcube.move(move3std[this.move3[i]]);
+		const facelet = solcube.to333Facelet();
+		const sol = this.search333.solution(facelet, 21, 1e6, 500, 0);
+		if (sol.startsWith("Error")) throw new Error(`@cubegin/scramble-core: min2phase returned ${sol} during 4x4 reduction`);
+		const sol333 = toMove(sol);
+		for (const move of sol333) solcube.move(move);
+		this.solution = solcube.getMoveString(this.inverseSolution, this.withRotation);
+	}
+	search1(ct, sym, maxLength, lastMove, depth) {
+		if (ct === 0 && maxLength < 5) return maxLength === 0 && this.init2(sym, lastMove);
+		for (let axis = 0; axis < 27; axis += 3) {
+			if (axis === lastMove || axis === lastMove - 9 || axis === lastMove - 18) continue;
+			for (let power = 0; power < 3; power += 1) {
+				const move = axis + power;
+				let ctx = Center1.ctsmv[ct][Center1.symmove[sym][move]];
+				const prun = Center1.csprun[ctx >>> 6];
+				if (prun >= maxLength) {
+					if (prun > maxLength) break;
+					continue;
+				}
+				const symx = Center1.symmult[sym][ctx & 63];
+				ctx >>>= 6;
+				this.move1[depth] = move;
+				if (this.search1(ctx, symx, maxLength - 1, axis, depth + 1)) return true;
+			}
+		}
+		return false;
+	}
+	init2(sym, _lastMove) {
+		this.c1.copy(this.cube);
+		for (let i = 0; i < this.length1; i += 1) this.c1.move(this.move1[i]);
+		switch (Center1.finish[sym]) {
+			case 0:
+				this.c1.move(24);
+				this.c1.move(35);
+				this.move1[this.length1] = 24;
+				this.move1[this.length1 + 1] = 35;
+				this.add1 = true;
+				sym = 19;
+				break;
+			case 12869:
+				this.c1.move(18);
+				this.c1.move(29);
+				this.move1[this.length1] = 18;
+				this.move1[this.length1 + 1] = 29;
+				this.add1 = true;
+				sym = 34;
+				break;
+			case 735470:
+				this.add1 = false;
+				sym = 0;
+				break;
+			default: return false;
+		}
+		this.ct2.set(this.c1.getCenter(), this.c1.getEdge().getParity());
+		const s2ct = this.ct2.getct();
+		const s2rl = this.ct2.getrl();
+		if (!Number.isSafeInteger(s2ct) || !Number.isSafeInteger(s2rl) || s2ct < 0 || s2ct >= 6435 || s2rl < 0 || s2rl >= 70) throw new Error(`@cubegin/scramble-core: invalid phase 2 coordinate ct=${s2ct} rl=${s2rl}`);
+		const ctp = Center2.ctprun[s2ct * 70 + s2rl];
+		this.c1.value = ctp + this.length1;
+		this.c1.length1 = this.length1;
+		this.c1.add1 = this.add1;
+		this.c1.sym = sym;
+		this.p1SolsCnt += 1;
+		this.pushP1Solution(this.c1);
+		return this.p1SolsCnt === PHASE1_SOLUTIONS;
+	}
+	pushP1Solution(cube) {
+		if (this.p1sols.length < PHASE2_ATTEMPTS) {
+			this.p1sols.push(new FullCube(cube));
+			return;
+		}
+		let maxIndex = 0;
+		for (let i = 1; i < this.p1sols.length; i += 1) if (this.p1sols[i].value > this.p1sols[maxIndex].value) maxIndex = i;
+		if (this.p1sols[maxIndex].value > cube.value) this.p1sols[maxIndex].copy(cube);
+	}
+	search2(ct, rl, maxLength, lastMove, depth) {
+		if (ct === 0 && Center2.ctprun[rl] === 0 && maxLength === 0) return this.init3();
+		for (let move = 0; move < 23; move += 1) {
+			if (ckmv2[lastMove][move]) {
+				move = skipAxis2[move];
+				continue;
+			}
+			const ctx = Center2.ctmv[ct][move];
+			const rlx = Center2.rlmv[rl][move];
+			const prun = Center2.ctprun[ctx * 70 + rlx];
+			if (prun >= maxLength) {
+				if (prun > maxLength) move = skipAxis2[move];
+				continue;
+			}
+			this.move2[depth] = move2std[move];
+			if (this.search2(ctx, rlx, maxLength - 1, move, depth + 1)) return true;
+		}
+		return false;
+	}
+	init3() {
+		this.c2.copy(this.c1);
+		for (let i = 0; i < this.length2; i += 1) this.c2.move(this.move2[i]);
+		if (!this.c2.checkEdge()) return false;
+		const edgeParity = this.e12.setFromEdgeCube(this.c2.getEdge());
+		this.ct3.set(this.c2.getCenter(), edgeParity ^ this.c2.getCorner().getParity());
+		const ct = this.ct3.getct();
+		const prun = Edge3.getprun(this.e12.getsym());
+		const candidate = this.arr2[this.arr2idx] ?? new FullCube(this.c2);
+		this.arr2[this.arr2idx] = candidate;
+		candidate.copy(this.c2);
+		candidate.value = this.length1 + this.length2 + Math.max(prun, Center3.prun[ct]);
+		candidate.length2 = this.length2;
+		this.arr2idx += 1;
+		return this.arr2idx === this.arr2.length;
+	}
+	search3(edge, ct, prun, maxLength, lastMove, depth) {
+		if (maxLength === 0) return edge === 0 && ct === 0;
+		this.tempe[depth].set(edge);
+		for (let move = 0; move < 17; move += 1) {
+			if (ckmv3[lastMove][move]) {
+				move = skipAxis3[move];
+				continue;
+			}
+			const ctx = Center3.ctmove[ct][move];
+			const prun1 = Center3.prun[ctx];
+			if (prun1 >= maxLength) {
+				if (prun1 > maxLength && move < 14) move = skipAxis3[move];
+				continue;
+			}
+			const edgex = Edge3.getmvrot(this.tempe[depth].edge, move << 3, 10);
+			let symcord1x = Edge3.raw2sym[Math.floor(edgex / Edge3.N_RAW)];
+			const symx = symcord1x & 7;
+			symcord1x >>>= 3;
+			const cord2x = Edge3.getmvrot(this.tempe[depth].edge, move << 3 | symx, 10) % Edge3.N_RAW;
+			const prunx = Edge3.getprun(symcord1x * Edge3.N_RAW + cord2x, prun);
+			if (prunx >= maxLength) {
+				if (prunx > maxLength && move < 14) move = skipAxis3[move];
+				continue;
+			}
+			if (this.search3(edgex, ctx, prunx, maxLength - 1, move, depth + 1)) {
+				this.move3[depth] = move;
+				return true;
+			}
+		}
+		return false;
+	}
+};
+//#endregion
+export { Search };

package/dist/scramble-core/src/solvers/threephase/tables.mjs

@@ -0,0 +1,201 @@
+const move2str = [
+	"U",
+	"U2",
+	"U'",
+	"R",
+	"R2",
+	"R'",
+	"F",
+	"F2",
+	"F'",
+	"D",
+	"D2",
+	"D'",
+	"L",
+	"L2",
+	"L'",
+	"B",
+	"B2",
+	"B'",
+	"Uw",
+	"Uw2",
+	"Uw'",
+	"Rw",
+	"Rw2",
+	"Rw'",
+	"Fw",
+	"Fw2",
+	"Fw'",
+	"Dw",
+	"Dw2",
+	"Dw'",
+	"Lw",
+	"Lw2",
+	"Lw'",
+	"Bw",
+	"Bw2",
+	"Bw'"
+];
+const move2std = [
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	16,
+	17,
+	19,
+	21,
+	22,
+	23,
+	25,
+	28,
+	30,
+	31,
+	32,
+	34,
+	36
+];
+const move3std = [
+	0,
+	1,
+	2,
+	4,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	13,
+	15,
+	16,
+	17,
+	19,
+	22,
+	25,
+	28,
+	31,
+	34,
+	36
+];
+const Cnk = Array.from({ length: 25 }, () => Array.from({ length: 25 }, () => 0));
+const fact = Array.from({ length: 13 }, () => 0);
+for (let i = 0; i < 25; i += 1) {
+	Cnk[i][i] = 1;
+	Cnk[i][0] = 1;
+}
+for (let i = 1; i < 25; i += 1) for (let j = 1; j <= i; j += 1) Cnk[i][j] = Cnk[i - 1][j] + Cnk[i - 1][j - 1];
+fact[0] = 1;
+for (let i = 0; i < 12; i += 1) fact[i + 1] = fact[i] * (i + 1);
+const std2move = Array.from({ length: 37 }, () => 0);
+const std3move = Array.from({ length: 37 }, () => 0);
+const ckmv = Array.from({ length: 37 }, () => Array.from({ length: 36 }, () => false));
+const ckmv2 = Array.from({ length: 29 }, () => Array.from({ length: 28 }, () => false));
+const ckmv3 = Array.from({ length: 21 }, () => Array.from({ length: 20 }, () => false));
+const skipAxis = Array.from({ length: 36 }, () => 0);
+const skipAxis2 = Array.from({ length: 28 }, () => 0);
+const skipAxis3 = Array.from({ length: 20 }, () => 0);
+for (let i = 0; i < 29; i += 1) std2move[move2std[i]] = i;
+for (let i = 0; i < 21; i += 1) std3move[move3std[i]] = i;
+for (let i = 0; i < 36; i += 1) {
+	for (let j = 0; j < 36; j += 1) ckmv[i][j] = Math.floor(i / 3) === Math.floor(j / 3) || Math.floor(i / 3) % 3 === Math.floor(j / 3) % 3 && i > j;
+	ckmv[36][i] = false;
+}
+for (let i = 0; i < 29; i += 1) for (let j = 0; j < 28; j += 1) ckmv2[i][j] = ckmv[move2std[i]][move2std[j]];
+for (let i = 0; i < 21; i += 1) for (let j = 0; j < 20; j += 1) ckmv3[i][j] = ckmv[move3std[i]][move3std[j]];
+for (let i = 0; i < 36; i += 1) {
+	skipAxis[i] = 36;
+	for (let j = i; j < 36; j += 1) if (!ckmv[i][j]) {
+		skipAxis[i] = j - 1;
+		break;
+	}
+}
+for (let i = 0; i < 28; i += 1) {
+	skipAxis2[i] = 28;
+	for (let j = i; j < 28; j += 1) if (!ckmv2[i][j]) {
+		skipAxis2[i] = j - 1;
+		break;
+	}
+}
+for (let i = 0; i < 20; i += 1) {
+	skipAxis3[i] = 20;
+	for (let j = i; j < 20; j += 1) if (!ckmv3[i][j]) {
+		skipAxis3[i] = j - 1;
+		break;
+	}
+}
+const swap = (arr, a, b, c, d, key) => {
+	let temp;
+	switch (key) {
+		case 0:
+			temp = arr[d];
+			arr[d] = arr[c];
+			arr[c] = arr[b];
+			arr[b] = arr[a];
+			arr[a] = temp;
+			return;
+		case 1:
+			temp = arr[a];
+			arr[a] = arr[c];
+			arr[c] = temp;
+			temp = arr[b];
+			arr[b] = arr[d];
+			arr[d] = temp;
+			return;
+		case 2:
+			temp = arr[a];
+			arr[a] = arr[b];
+			arr[b] = arr[c];
+			arr[c] = arr[d];
+			arr[d] = temp;
+			return;
+		default: return;
+	}
+};
+const set8Perm = (arr, idx) => {
+	let val = 1985229328;
+	for (let i = 0; i < 7; i += 1) {
+		const p = fact[7 - i];
+		let v = Math.floor(idx / p);
+		idx -= v * p;
+		v <<= 2;
+		arr[i] = val >>> v & 15;
+		const m = (1 << v) - 1;
+		val = (val & m) + (val >>> 4 & ~m);
+	}
+	arr[7] = val;
+};
+const parity = (arr) => {
+	let value = 0;
+	for (let i = 0; i < arr.length; i += 1) for (let j = i; j < arr.length; j += 1) if (arr[i] > arr[j]) value ^= 1;
+	return value;
+};
+const toMove = (algorithm) => {
+	const moves = [];
+	const tokens = algorithm.trim().length === 0 ? [] : algorithm.trim().split(/\s+/);
+	for (const token of tokens) {
+		const match = token.match(/^([URFDLB])w?(2|')?$/);
+		if (match === null) continue;
+		const faceIndex = "URFDLB".indexOf(match[1]);
+		const isWide = token.includes("w");
+		let move = faceIndex * 3 + (isWide ? 18 : 0);
+		if (match[2] === "2") move += 1;
+		if (match[2] === "'") move += 2;
+		moves.push(move);
+	}
+	return moves;
+};
+//#endregion
+export { Cnk, ckmv2, ckmv3, move2std, move2str, move3std, parity, set8Perm, skipAxis2, skipAxis3, swap, toMove };

package/dist/scramble-core/src/solvers/two-by-two-solver.d.mts

@@ -0,0 +1,15 @@
+import { RandomSource } from "../random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/solvers/two-by-two-solver.d.ts
+interface TwoByTwoState {
+  permutation: number;
+  orientation: number;
+}
+declare class TwoByTwoSolver {
+  randomState(random: RandomSource): TwoByTwoState;
+  solveIn(state: TwoByTwoState, maxLength: number): string | null;
+  generateExactly(state: TwoByTwoState, length: number): string;
+  private solve;
+}
+//#endregion
+export { TwoByTwoSolver, TwoByTwoState };