cubing 0.23.0 → 0.24.0-pre1

package/src/cubing/search/inside/solve/puzzles/2x2x2.ts

@@ -1,92 +0,0 @@
-import type { Alg } from "../../../../alg";
-import {
-  KPuzzle,
-  KPuzzleDefinition,
-  Transformation,
-} from "../../../../kpuzzle";
-import { puzzles } from "../../../../puzzles";
-import { mustBeInsideWorker } from "../../inside-worker";
-import {
-  randomPermute,
-  randomUIntBelowFactory,
-} from "../../../../vendor/random-uint-below";
-import type { SGSCachedData } from "../parseSGS";
-import { TrembleSolver } from "../tremble";
-
-// Empirical ly determined depth:
-// - ≈11 moves on average (as opposed to >13 moves for depth 2),
-// - in close to 40ms(on a MacBook Pro).
-const TREMBLE_DEPTH = 3;
-
-let cachedTrembleSolver: Promise<TrembleSolver> | null = null;
-async function getCachedTrembleSolver(): Promise<TrembleSolver> {
-  return (
-    cachedTrembleSolver ||
-    (cachedTrembleSolver = (async (): Promise<TrembleSolver> => {
-      const json: SGSCachedData = await (
-        await import("./2x2x2.sgs.json")
-      ).cachedData222();
-      return new TrembleSolver(
-        await puzzles["2x2x2"].def(),
-        json,
-        "URFLBD".split(""),
-      );
-    })())
-  );
-}
-
-export async function preInitialize222(): Promise<void> {
-  await getCachedTrembleSolver();
-}
-
-// TODO: fix def consistency.
-export async function solve222(state: Transformation): Promise<Alg> {
-  mustBeInsideWorker();
-  const trembleSolver = await getCachedTrembleSolver();
-  const alg = await trembleSolver.solve(state, TREMBLE_DEPTH, () => 4); // TODO: Attach quantum move order lookup to puzzle.
-  return alg;
-}
-
-// TODO: factor out and test.
-async function randomizeOrbit(
-  def: KPuzzleDefinition,
-  orbitName: string,
-  state: Transformation,
-  options?: { orientationSum?: number },
-): Promise<void> {
-  const randomUIntBelow = await randomUIntBelowFactory();
-  await randomPermute(state[orbitName].permutation);
-
-  const orbitDef = def.orbits[orbitName];
-  const ori = state[orbitName].orientation;
-
-  let sum = 0;
-  for (let i = 0; i < orbitDef.numPieces; i++) {
-    const o = randomUIntBelow(orbitDef.orientations);
-    ori[i] = o;
-    sum += o;
-  }
-
-  // console.log("aaaa", options && "orientationSum" in options);
-  if (options && "orientationSum" in options) {
-    // console.log("sfdsf", options!.orientationSum),
-    ori[0] =
-      (((ori[0] + options.orientationSum! - sum) % orbitDef.orientations) +
-        orbitDef.orientations) %
-      orbitDef.orientations;
-  }
-}
-
-// TODO: Use SGS?
-export async function random222State(): Promise<Transformation> {
-  const nonExtensibleDef = await puzzles["2x2x2"].def();
-  const def = Object.assign({}, nonExtensibleDef);
-  const kpuzzle = new KPuzzle(def);
-  const stateCopy: Transformation = JSON.parse(JSON.stringify(kpuzzle.state)); // TODO
-  await randomizeOrbit(def, "CORNERS", stateCopy, { orientationSum: 0 });
-  return stateCopy;
-}
-
-export async function random222Scramble(): Promise<Alg> {
-  return await solve222(await random222State());
-}

package/src/cubing/search/inside/solve/puzzles/3x3x3/convert.ts

@@ -1,137 +0,0 @@
-/*
-
-Face order:
-
- U
-LFRB
- D
-
-         | 0| 1| 2|
-         | 3| 4| 5|
-         | 6| 7| 8|
-| 9|10|11|18|19|20|27|28|29|36|37|38|
-|12|13|14|21|22|23|30|31|32|39|40|41|
-|15|16|17|24|25|26|33|34|35|42|43|44|
-         |45|46|47|
-         |48|49|50|
-         |51|52|53|
-*/
-
-import type { Transformation } from "../../../../../kpuzzle";
-
-const reidEdgeOrder = "UF UR UB UL DF DR DB DL FR FL BR BL".split(" ");
-const reidCornerOrder = "UFR URB UBL ULF DRF DFL DLB DBR".split(" ");
-const centerOrder = "U L F R B D".split(" ");
-
-// const stickers = [reidEdgeOrder, reidCornerOrder, centerOrder];
-
-// /*
-//                |1 20|0 20|1 10|
-//                |0 30|2 00|0 10|
-//                |1 30|0 00|1 00|
-// |1 22|0 31|1 31|1 32|0 01|1 01|1 02|0 11|1 11|1 12|0 21|1 21|
-// |0111|2 10|0 91|0 90|2 20|0 80|0 81|2 30|0101|0100|2 40|0110|
-// |1 61|0 71|1 52|1 51|0 41|1 42|1 41|0 51|1 72|1 71|0 61|1 62|
-//                |1 50|0 40|1 40|
-//                |0 70|2 50|0 50|
-//                |1 60|0 60|1 70|
-// */
-
-const map: [number, number, number][] = [
-  [1, 2, 0],
-  [0, 2, 0],
-  [1, 1, 0],
-  [0, 3, 0],
-  [2, 0, 0],
-  [0, 1, 0],
-  [1, 3, 0],
-  [0, 0, 0],
-  [1, 0, 0],
-  [1, 0, 2],
-  [0, 1, 1],
-  [1, 1, 1],
-  [0, 8, 1],
-  [2, 3, 0],
-  [0, 10, 1],
-  [1, 4, 1],
-  [0, 5, 1],
-  [1, 7, 2],
-  [1, 3, 2],
-  [0, 0, 1],
-  [1, 0, 1],
-  [0, 9, 0],
-  [2, 2, 0],
-  [0, 8, 0],
-  [1, 5, 1],
-  [0, 4, 1],
-  [1, 4, 2],
-  [1, 5, 0],
-  [0, 4, 0],
-  [1, 4, 0],
-  [0, 7, 0],
-  [2, 5, 0],
-  [0, 5, 0],
-  [1, 6, 0],
-  [0, 6, 0],
-  [1, 7, 0],
-  [1, 2, 2],
-  [0, 3, 1],
-  [1, 3, 1],
-  [0, 11, 1],
-  [2, 1, 0],
-  [0, 9, 1],
-  [1, 6, 1],
-  [0, 7, 1],
-  [1, 5, 2],
-  [1, 1, 2],
-  [0, 2, 1],
-  [1, 2, 1],
-  [0, 10, 0],
-  [2, 4, 0],
-  [0, 11, 0],
-  [1, 7, 1],
-  [0, 6, 1],
-  [1, 6, 2],
-];
-
-function rotateLeft(s: string, i: number): string {
-  return s.slice(i) + s.slice(0, i);
-}
-
-function toReid333Struct(state: Transformation): string[][] {
-  const output: string[][] = [[], []];
-  for (let i = 0; i < 6; i++) {
-    if (state["CENTERS"].permutation[i] !== i) {
-      throw new Error("non-oriented puzzles are not supported");
-    }
-  }
-  for (let i = 0; i < 12; i++) {
-    output[0].push(
-      rotateLeft(
-        reidEdgeOrder[state["EDGES"].permutation[i]],
-        state["EDGES"].orientation[i],
-      ),
-    );
-  }
-  for (let i = 0; i < 8; i++) {
-    output[1].push(
-      rotateLeft(
-        reidCornerOrder[state["CORNERS"].permutation[i]],
-        state["CORNERS"].orientation[i],
-      ),
-    );
-  }
-  output.push(centerOrder);
-  return output;
-}
-
-// function toReid333String(state: Transformation): string {
-//   return toReid333Struct(state)
-//     .map((l) => l.join(" "))
-//     .join(" ");
-// }
-
-export function toMin2PhaseState(state: Transformation): string {
-  const reid = toReid333Struct(state);
-  return map.map(([orbit, perm, ori]) => reid[orbit][perm][ori]).join("");
-}

package/src/cubing/search/inside/solve/puzzles/3x3x3/filter.ts

@@ -1,60 +0,0 @@
-import { Move } from "../../../../../alg";
-import {
-  KPuzzle,
-  areOrbitTransformationsEquivalent,
-  KPuzzleDefinition,
-  Transformation,
-} from "../../../../../kpuzzle";
-
-export function isEquivalentTranformationIgnoringCENTERS(
-  def: KPuzzleDefinition,
-  t1: Transformation,
-  t2: Transformation,
-): boolean {
-  for (const orbitName in def.orbits) {
-    if (
-      !areOrbitTransformationsEquivalent(def, orbitName, t1, t2, {
-        ignoreOrientation: orbitName === "CENTERS",
-      })
-    ) {
-      return false;
-    }
-  }
-  return true;
-}
-
-export function passesFilter(
-  def: KPuzzleDefinition,
-  state: Transformation,
-): boolean {
-  const kpuzzle = new KPuzzle(def);
-  if (isEquivalentTranformationIgnoringCENTERS(def, kpuzzle.state, state)) {
-    return false;
-  }
-
-  for (const face of "ULFRBD") {
-    for (let amount = 1; amount < 4; amount++) {
-      kpuzzle.reset();
-      kpuzzle.applyMove(new Move(face, amount));
-      if (isEquivalentTranformationIgnoringCENTERS(def, kpuzzle.state, state)) {
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
-
-// TODO: implement tests
-// {
-//   const def = await puzzles["3x3x3"].def();
-//   const kpuzzle = new KPuzzle(def);
-//   console.log(passesFilter(def, kpuzzle.state));
-//   kpuzzle.applyAlg(parse("R"));
-//   console.log(passesFilter(def, kpuzzle.state));
-//   kpuzzle.applyAlg(parse("D"));
-//   console.log(passesFilter(def, kpuzzle.state));
-//   kpuzzle.reset();
-//   kpuzzle.applyAlg(parse("(R' U' R U')5"));
-//   console.log(passesFilter(def, kpuzzle.state));
-// }

package/src/cubing/search/inside/solve/puzzles/3x3x3/index.ts

@@ -1,67 +0,0 @@
-import { Alg, AlgBuilder } from "../../../../../alg";
-import { KPuzzle, Transformation } from "../../../../../kpuzzle";
-import { puzzles } from "../../../../../puzzles";
-import { mustBeInsideWorker } from "../../../inside-worker";
-import { addOrientationSuffix } from "../../addOrientationSuffix";
-import { randomChoiceFactory } from "../../../../../vendor/random-uint-below";
-import { toMin2PhaseState } from "./convert";
-import { passesFilter } from "./filter";
-import { sgs3x3x3 } from "./legacy-sgs";
-
-export async function random333State(): Promise<Transformation> {
-  const def = await puzzles["3x3x3"].def();
-  const kpuzzle = new KPuzzle(def);
-  for (const piece of sgs3x3x3) {
-    kpuzzle.applyAlg(
-      Alg.fromString(((await randomChoiceFactory()) as any)(piece)),
-    );
-  }
-  if (!passesFilter(def, kpuzzle.state)) {
-    return random333State();
-  }
-  return kpuzzle.state;
-}
-
-let cachedImport: Promise<
-  typeof import("../../../../../vendor/min2phase/gwt")
-> | null = null;
-function dynamicMin2phaseGWT(): Promise<
-  typeof import("../../../../../vendor/min2phase/gwt")
-> {
-  return (cachedImport ??= import("../../../../../vendor/min2phase/gwt"));
-}
-
-export async function solve333(s: Transformation): Promise<Alg> {
-  mustBeInsideWorker();
-  return Alg.fromString(
-    (await dynamicMin2phaseGWT()).solveState(toMin2PhaseState(s)),
-  );
-}
-
-export async function random333Scramble(): Promise<Alg> {
-  return solve333(await random333State());
-}
-
-export async function initialize333(): Promise<void> {
-  (await dynamicMin2phaseGWT()).initialize();
-}
-
-const randomSuffixes = [
-  [null, "Rw", "Rw2", "Rw'", "Fw", "Fw'"],
-  [null, "Dw", "Dw2", "Dw'"],
-];
-
-export async function random333OrientedScramble(): Promise<Alg> {
-  return addOrientationSuffix(await random333Scramble(), randomSuffixes);
-}
-
-const extraBit = new Alg("R' U' F");
-export async function random333FewestMovesScramble(): Promise<Alg> {
-  const algBuilder = new AlgBuilder();
-  const unorientedScramble = await random333Scramble();
-  algBuilder.experimentalPushAlg(extraBit);
-  // TODO:Avoid cancellable moves.
-  algBuilder.experimentalPushAlg(unorientedScramble);
-  algBuilder.experimentalPushAlg(extraBit);
-  return algBuilder.toAlg();
-}

package/src/cubing/search/inside/solve/puzzles/3x3x3/legacy-sgs.ts

@@ -1,291 +0,0 @@
-// TODO: Verify
-export const sgs3x3x3: string[][] = [
-  [
-    "R U'",
-    "R2 B", //
-    "D2 B2",
-    "D' L B'", //
-    "R' U'",
-    "B", //
-    "D B2",
-    "R' B", //
-    "L' U",
-    "L2 B'", //
-    "B2",
-    "D L B'", //
-    "L U",
-    "B'", //
-    "U'",
-    "R B", //
-    "D' B2",
-    "L B'", //
-    "U2",
-    "U L' B'", //
-    "",
-    "U' L' B'", //
-    "U",
-    "L' B'",
-  ],
-  [
-    "F2 L2",
-    "F' L'",
-    "R' F L2", //
-    "D' L2",
-    "F L2",
-    "F2 L'", //
-    "R' F' L'",
-    "R2 F L2",
-    "R2 F2 L'", //
-    "L2",
-    "F L'",
-    "D' L", //
-    "D2 L2",
-    "R2 F' L'",
-    "D L", //
-    "",
-    "L2 F L'",
-    "L F' L2", //
-    "L F L'",
-    "F' L2",
-    "L'", //
-    "D L2",
-    "D F L'",
-    "L",
-  ],
-  [
-    "R B U2 B'",
-    "R2 B U' B'", //
-    "F2 B U B'",
-    "F B2 L' B2", //
-    "B2 L B2",
-    "B U' B'", //
-    "R2 B U2 B'",
-    "R' B U' B'", //
-    "B2 L' B2",
-    "F B U B'", //
-    "B2 U' B2",
-    "B' L B", //
-    "L F' B D' B'",
-    "B' U' B2 D B'", //
-    "B U2 B'",
-    "R B U' B'", //
-    "B2 L2 B2",
-    "D' B' L B", //
-    "B U B'",
-    "F' B2 L' B2", //
-    "",
-    "B2 L' B' U' B'",
-  ],
-  [
-    "U F2 L2 U'",
-    "F' U L' U'", //
-    "F2 U L' U'",
-    "U F L2 U'", //
-    "U2 B2 U2",
-    "R' U' B U", //
-    "D2 U L U'",
-    "D U2 B' U2", //
-    "U L2 U'",
-    "F U L' U'", //
-    "D U L U'",
-    "U2 B' U2", //
-    "",
-    "U2 B' U' L' U'", //
-    "U2 L' U2",
-    "U' B U", //
-    "U L U'",
-    "D' U2 B' U2", //
-    "U L' U'",
-    "U2 B U2",
-  ],
-  [
-    "R' D' F2",
-    "F'", //
-    "F2",
-    "D R F'", //
-    "R D' F2",
-    "R2 F'", //
-    "D' F2",
-    "R F'", //
-    "F2 R' D' F2",
-    "F", //
-    "D2 F2",
-    "D' R F'", //
-    "R2 D' F2",
-    "R' F'", //
-    "D F2",
-    "D2 R F'", //
-    "",
-    "F R' D' F2",
-  ],
-  [
-    "R' D2 F' D F",
-    "R F2 R2 F2",
-    "R2 F' D2 F", //
-    "F' R2 D2 F",
-    "L D' L'",
-    "D F' D2 F", //
-    "F2 R2 F2",
-    "R F' D2 F",
-    "F' R2 D' F", //
-    "F' R' D2 F",
-    "F2 R' F2",
-    "L D L'", //
-    "F' R D' F",
-    "F2 R F2",
-    "F' D2 F", //
-    "",
-    "L D2 R D' L'",
-    "F' D2 F' R F2", //
-    "D2 R2 F2 R2 F2",
-    "D F' D' F",
-    "F' D F",
-  ],
-  [
-    "U F2 U'",
-    "R U F' U'", //
-    "D R U F2 U'",
-    "U F U'", //
-    "R2 U F2 U'",
-    "R' U F' U'", //
-    "R U F2 U'",
-    "R2 U F' U'", //
-    "",
-    "U L D L' F U'", //
-    "F2 D' R D F2",
-    "D2 U F U'", //
-    "R' U F2 U'",
-    "U F' U'", //
-    "F2 D2 R D2 F2",
-    "D U F U'",
-  ],
-  [
-    "R2",
-    "R' B' D B", //
-    "D R'",
-    "F' R2 F", //
-    "",
-    "R B' D B", //
-    "R'",
-    "B' D B", //
-    "D' R'",
-    "D2 F' R2 F", //
-    "R",
-    "R2 B' D B", //
-    "D2 R'",
-    "B' D' B",
-  ],
-  [
-    "R2 D' R2",
-    "F' R' F R",
-    "R D' R2 D R'", //
-    "D2 R2 D2 R2",
-    "R' D' F' R F",
-    "U F D F' U'", //
-    "",
-    "R2 D2 B R' B' R'",
-    "R' F D' F2 R F", //
-    "R2 D R2",
-    "F2 U F U' F",
-    "R' D F' R F", //
-    "D R2 D2 R2",
-    "U F D' F' U'",
-    "D R' D2 F' R F", //
-    "R2 D2 R2",
-    "U F D2 F' U'",
-    "R' D2 F' R F",
-  ],
-  [
-    "B R B'",
-    "F D F' B R2 B'", //
-    "D B R2 B'",
-    "D2 B R' B'", //
-    "B R2 B'",
-    "D B R' B'", //
-    "D' B R2 B'",
-    "B R' B'", //
-    "",
-    "B R2 B' D B R' B'", //
-    "D2 B R2 B'",
-    "D' B R' B'",
-  ],
-  [
-    "",
-    "R' D R F D2 F'", //
-    "R' D R",
-    "D F D' F'", //
-    "R F' R' F",
-    "F D' F'", //
-    "R' D' R",
-    "F D2 F'", //
-    "R' D2 R",
-    "F D F'",
-  ],
-  [
-    "",
-    "F2 D2 R F' R' D2 F' D2 F'",
-    "F2 D2 F' D' F D' F' D2 F'", //
-    "F2 D F2 D F2 D2 F2",
-    "D2 F L D2 L' D2 F'",
-    "D F D2 L D2 L' F'", //
-    "R' D B' D2 B D' R",
-    "R' D2 B' D2 B R",
-    "F D2 F' D F D F'", //
-    "F D' L D2 L' D F'",
-    "B D' F D B' D' F'",
-    "F D2 L D2 L' F'", //
-    "F D' L D L' D F'",
-    "F L D2 L' D2 F'",
-    "R' B' D2 B D2 R",
-  ],
-  [
-    "D'",
-    "F L D L' D' F'", //
-    "D2",
-    "L B D B' D' L'", //
-    "D",
-    "B' L' D' L D B", //
-    "",
-    "D F L D L' D' F'",
-  ],
-  [
-    "F' D2 F D F' D F",
-    "F' D' R' D R F", //
-    "F' R' D' R D F",
-    "B D R D' R' B'", //
-    "",
-    "D B' D' L' D L B",
-  ],
-  [
-    "D F D F' D F D2 F'",
-    "F' U2 B' R' B U2 F' L F' L' F'", //
-    "",
-    "D2 L D L2 F L F2 D F",
-  ],
-  [
-    "L B' L' F L B L' F'",
-    "F2 U F' D2 F U' F' D2 F'",
-    "D' F' D B D' F D B'", //
-    "F L2 F R2 F' L2 F R2 F2",
-    "D B D' F' D B' D' F",
-    "R F L F' R' F L' F'", //
-    "",
-    "D2 B L' U2 L B' D2 B L' U2 L B'",
-    "D2 F R' U2 R F' D2 F R' U2 R F'", //
-    "R F L' F' R' F L F'",
-    "D F D' B' D F' D' B",
-    "L2 F2 L' B2 L F2 L' B2 L'",
-  ],
-  [
-    "L B R' B' L' B R B'",
-    "R' B R F' R' B' R F",
-    "L D2 L U L' D2 L U' L2", //
-    "",
-    "D2 B' D2 F D' L2 F L2 F' D2 B D' F'",
-    "D2 F' R' F R2 B' D2 B D2 R' F D2 F'", //
-    "L B L' F L B' L' F'",
-    "F' D2 F' U' F D2 F' U F2",
-    "D' B' D F D' B D F'",
-  ],
-  ["", "D2 F' L U2 L' F D2 F' L U2 L' F", "D2 B' R U2 R' B D2 B' R U2 R' B"],
-];