cubegin 0.0.1

package/dist/scramble-core/src/solvers/sq12phase/shape.mjs

@@ -0,0 +1,214 @@
+//#region .build/vendor/scramble-core/src/solvers/sq12phase/shape.ts
+const N_SHAPES = 3678;
+const N_SHAPE_STATES = N_SHAPES * 2;
+const FACE_TURN_METRIC = 0;
+const WCA_TURN_METRIC = 1;
+const SEARCH_METRIC = WCA_TURN_METRIC;
+const HALF_LAYER = [
+	0,
+	3,
+	6,
+	12,
+	15,
+	24,
+	27,
+	30,
+	48,
+	51,
+	54,
+	60,
+	63
+];
+const SOLVED_SHAPE_WITH_PARITY = 7191990;
+let cachedTables;
+var ShapeCoordinate = class {
+	top = 0;
+	bottom = 0;
+	parity = 0;
+	constructor(shapeIdx) {
+		this.shapeIdx = shapeIdx;
+	}
+	getIdx() {
+		return getShape2IdxFrom(this.shapeIdx, this.parity << 24 | this.top << 12 | this.bottom);
+	}
+	setIdx(index) {
+		this.parity = index & 1;
+		this.top = this.shapeIdx[index >> 1];
+		this.bottom = this.top & 4095;
+		this.top >>= 12;
+	}
+	topMove() {
+		let move = 0;
+		let moveParity = 0;
+		do {
+			if ((this.top & 2048) === 0) {
+				move += 1;
+				this.top <<= 1;
+			} else {
+				move += 2;
+				this.top = this.top << 2 ^ 12291;
+			}
+			moveParity = 1 - moveParity;
+		} while ((popCount(this.top & 63) & 1) !== 0);
+		if ((popCount(this.top) & 2) === 0) this.parity ^= moveParity;
+		return move;
+	}
+	bottomMove() {
+		let move = 0;
+		let moveParity = 0;
+		do {
+			if ((this.bottom & 2048) === 0) {
+				move += 1;
+				this.bottom <<= 1;
+			} else {
+				move += 2;
+				this.bottom = this.bottom << 2 ^ 12291;
+			}
+			moveParity = 1 - moveParity;
+		} while ((popCount(this.bottom & 63) & 1) !== 0);
+		if ((popCount(this.bottom) & 2) === 0) this.parity ^= moveParity;
+		return move;
+	}
+	twistMove() {
+		const topSlice = this.top & 63;
+		const topSliceCorners = popCount(topSlice);
+		const bottomSliceCorners = popCount(this.bottom & 4032);
+		this.parity ^= 1 & (topSliceCorners & bottomSliceCorners) >> 1;
+		this.top = this.top & 4032 | this.bottom >> 6 & 63;
+		this.bottom = this.bottom & 63 | topSlice << 6;
+	}
+};
+const getShape2Idx = (shapeWithParity) => getShape2IdxFrom(getShapeTables().shapeIdx, shapeWithParity);
+const getShapeTables = () => {
+	cachedTables ??= createShapeTables();
+	return cachedTables;
+};
+const createShapeTables = () => {
+	const shapeIdx = createShapeIndex();
+	const topMove = new Int32Array(N_SHAPE_STATES);
+	const bottomMove = new Int32Array(N_SHAPE_STATES);
+	const twistMove = new Int32Array(N_SHAPE_STATES);
+	const shape = new ShapeCoordinate(shapeIdx);
+	for (let index = 0; index < N_SHAPE_STATES; index += 1) {
+		shape.setIdx(index);
+		topMove[index] = shape.topMove() | shape.getIdx() << 4;
+		shape.setIdx(index);
+		bottomMove[index] = shape.bottomMove() | shape.getIdx() << 4;
+		shape.setIdx(index);
+		shape.twistMove();
+		twistMove[index] = shape.getIdx();
+	}
+	const shapePrun = new Int8Array(N_SHAPE_STATES);
+	const shapePrunOpt = new Int8Array(N_SHAPE_STATES);
+	shapePrun.fill(-1);
+	shapePrunOpt.fill(-1);
+	shapePrun[getShape2IdxFrom(shapeIdx, 14378715)] = 0;
+	shapePrun[getShape2IdxFrom(shapeIdx, 31157686)] = 0;
+	shapePrun[getShape2IdxFrom(shapeIdx, 23967451)] = 0;
+	shapePrun[getShape2IdxFrom(shapeIdx, 7191990)] = 0;
+	shapePrunOpt[getShape2IdxFrom(shapeIdx, SOLVED_SHAPE_WITH_PARITY)] = 0;
+	const tables = {
+		shapeIdx,
+		shapePrun,
+		shapePrunOpt,
+		topMove,
+		bottomMove,
+		twistMove
+	};
+	initPruning(tables, shapePrun, 4, FACE_TURN_METRIC);
+	initPruning(tables, shapePrunOpt, 1, SEARCH_METRIC);
+	return tables;
+};
+const createShapeIndex = () => {
+	const shapeIdx = new Int32Array(N_SHAPES);
+	let count = 0;
+	for (let index = 0; index < 2197 * 13; index += 1) {
+		const dr = HALF_LAYER[index % 13];
+		const dl = HALF_LAYER[Math.floor(index / 13) % 13];
+		const ur = HALF_LAYER[Math.floor(index / 13 / 13) % 13];
+		const value = HALF_LAYER[Math.floor(index / 13 / 13 / 13)] << 18 | ur << 12 | dl << 6 | dr;
+		if (popCount(value) === 16) {
+			shapeIdx[count] = value;
+			count += 1;
+		}
+	}
+	return shapeIdx;
+};
+const initPruning = (tables, pruning, doneStart, metric) => {
+	let done = doneStart;
+	let previousDone = 0;
+	let depth = -1;
+	while (done !== previousDone) {
+		previousDone = done;
+		depth += 1;
+		for (let index = 0; index < N_SHAPE_STATES; index += 1) {
+			if (pruning[index] !== depth) continue;
+			const twisted = tables.twistMove[index];
+			if (pruning[twisted] === -1) {
+				done += 1;
+				pruning[twisted] = depth + 1;
+			}
+			if (metric === FACE_TURN_METRIC) {
+				for (let move = 0, increment = 0, next = index; move !== 12; move += increment) {
+					const moved = tables.topMove[next];
+					increment = moved & 15;
+					next = moved >> 4;
+					if (pruning[next] === -1) {
+						done += 1;
+						pruning[next] = depth + 1;
+					}
+				}
+				for (let move = 0, increment = 0, next = index; move !== 12; move += increment) {
+					const moved = tables.bottomMove[next];
+					increment = moved & 15;
+					next = moved >> 4;
+					if (pruning[next] === -1) {
+						done += 1;
+						pruning[next] = depth + 1;
+					}
+				}
+			} else if (metric === WCA_TURN_METRIC) for (let move = 0, increment = 0, next = index; move !== 12; move += increment) {
+				const movedTop = tables.topMove[next];
+				increment = movedTop & 15;
+				next = movedTop >> 4;
+				for (let bottomMove = 0, bottomIncrement = 0, bottomNext = next; bottomMove !== 12; bottomMove += bottomIncrement) {
+					const movedBottom = tables.bottomMove[bottomNext];
+					bottomIncrement = movedBottom & 15;
+					bottomNext = movedBottom >> 4;
+					if (pruning[bottomNext] === -1) {
+						done += 1;
+						pruning[bottomNext] = depth + 1;
+					}
+				}
+			}
+		}
+	}
+};
+const getShape2IdxFrom = (shapeIdx, shapeWithParity) => {
+	const index = binarySearch(shapeIdx, shapeWithParity & 16777215);
+	if (index < 0) throw new RangeError("@cubegin/scramble-core: invalid Square-1 shape coordinate");
+	return index << 1 | shapeWithParity >> 24 & 1;
+};
+const binarySearch = (values, target) => {
+	let low = 0;
+	let high = values.length - 1;
+	while (low <= high) {
+		const middle = low + high >> 1;
+		const value = values[middle];
+		if (value < target) low = middle + 1;
+		else if (value > target) high = middle - 1;
+		else return middle;
+	}
+	return -1;
+};
+const popCount = (value) => {
+	let remaining = value >>> 0;
+	let count = 0;
+	while (remaining !== 0) {
+		remaining &= remaining - 1;
+		count += 1;
+	}
+	return count;
+};
+//#endregion
+export { getShape2Idx, getShapeTables, popCount };

package/dist/scramble-core/src/solvers/sq12phase/square.mjs

@@ -0,0 +1,135 @@
+//#region .build/vendor/scramble-core/src/solvers/sq12phase/square.ts
+const N_PERMUTATIONS = 40320;
+const N_MIDDLE_LAYER_STATES = N_PERMUTATIONS * 2;
+const FACTORIAL = [
+	1,
+	1,
+	2,
+	6,
+	24,
+	120,
+	720,
+	5040
+];
+let cachedTables;
+const createSquareCoordinate = () => ({
+	edgePerm: 0,
+	cornPerm: 0,
+	topEdgeFirst: false,
+	botEdgeFirst: false,
+	ml: 0
+});
+const set8Perm = (pieces, permutation) => {
+	let remaining = permutation;
+	let value = 1985229328;
+	for (let index = 0; index < 7; index += 1) {
+		const factorial = FACTORIAL[7 - index];
+		let piece = Math.floor(remaining / factorial);
+		remaining -= piece * factorial;
+		piece <<= 2;
+		pieces[index] = value >> piece & 7;
+		const mask = (1 << piece) - 1;
+		value = (value & mask) + (value >> 4 & ~mask);
+	}
+	pieces[7] = value;
+};
+const get8Perm = (pieces) => {
+	let permutation = 0;
+	let value = 1985229328;
+	for (let index = 0; index < 7; index += 1) {
+		const piece = pieces[index] << 2;
+		permutation = (8 - index) * permutation + (value >> piece & 7);
+		value -= 286331152 << piece;
+	}
+	return permutation;
+};
+const createMoveTables = () => {
+	const twistMove = new Uint16Array(N_PERMUTATIONS);
+	const topMove = new Uint16Array(N_PERMUTATIONS);
+	const bottomMove = new Uint16Array(N_PERMUTATIONS);
+	const pieces = Array.from({ length: 8 }, () => 0);
+	for (let permutation = 0; permutation < N_PERMUTATIONS; permutation += 1) {
+		set8Perm(pieces, permutation);
+		swap(pieces, 2, 4);
+		swap(pieces, 3, 5);
+		twistMove[permutation] = get8Perm(pieces);
+		set8Perm(pieces, permutation);
+		const topPiece = pieces[0];
+		pieces[0] = pieces[1];
+		pieces[1] = pieces[2];
+		pieces[2] = pieces[3];
+		pieces[3] = topPiece;
+		topMove[permutation] = get8Perm(pieces);
+		set8Perm(pieces, permutation);
+		const bottomPiece = pieces[4];
+		pieces[4] = pieces[5];
+		pieces[5] = pieces[6];
+		pieces[6] = pieces[7];
+		pieces[7] = bottomPiece;
+		bottomMove[permutation] = get8Perm(pieces);
+	}
+	return {
+		twistMove,
+		topMove,
+		bottomMove
+	};
+};
+const createPruningTable = ({ twistMove, topMove, bottomMove }) => {
+	const squarePrun = new Int8Array(N_MIDDLE_LAYER_STATES);
+	squarePrun.fill(-1);
+	squarePrun[0] = 0;
+	let depth = 0;
+	let done = 1;
+	while (done < N_MIDDLE_LAYER_STATES) {
+		const inverseFill = depth >= 11;
+		const findValue = inverseFill ? -1 : depth;
+		const checkValue = inverseFill ? depth : -1;
+		depth += 1;
+		for (let index = 0; index < N_MIDDLE_LAYER_STATES; index += 1) {
+			if (squarePrun[index] !== findValue) continue;
+			const ml = index & 1;
+			let permutation = index >> 1;
+			const twisted = twistMove[permutation] << 1 | 1 - ml;
+			if (squarePrun[twisted] === checkValue) {
+				done += 1;
+				squarePrun[inverseFill ? index : twisted] = depth;
+				if (inverseFill) continue;
+			}
+			for (let move = 0; move < 4; move += 1) {
+				permutation = topMove[permutation];
+				const moved = permutation << 1 | ml;
+				if (squarePrun[moved] !== checkValue) continue;
+				done += 1;
+				squarePrun[inverseFill ? index : moved] = depth;
+				if (inverseFill) break;
+			}
+			if (inverseFill && squarePrun[index] !== findValue) continue;
+			for (let move = 0; move < 4; move += 1) {
+				permutation = bottomMove[permutation];
+				const moved = permutation << 1 | ml;
+				if (squarePrun[moved] !== checkValue) continue;
+				done += 1;
+				squarePrun[inverseFill ? index : moved] = depth;
+				if (inverseFill) break;
+			}
+		}
+	}
+	return squarePrun;
+};
+const getSquareTables = () => {
+	cachedTables ??= (() => {
+		const moveTables = createMoveTables();
+		return {
+			...moveTables,
+			squarePrun: createPruningTable(moveTables)
+		};
+	})();
+	return cachedTables;
+};
+const swap = (pieces, first, second) => {
+	const piece = pieces[first];
+	pieces[first] = pieces[second];
+	pieces[second] = piece;
+};
+//#endregion
+export { createSquareCoordinate, get8Perm, getSquareTables };