cubing 0.22.0 → 0.24.0-pre2

package/src/cubing/kpuzzle/transformations.ts

@@ -1,258 +0,0 @@
-import type {
-  KPuzzleDefinition,
-  OrbitTransformation,
-  Transformation,
-} from "./definition_types";
-
-// this is the last identity orbit transformation we saw or looked at.
-let lasto: OrbitTransformation | null;
-
-function isIdentity(omod: number, o: OrbitTransformation): boolean {
-  if (o === lasto) {
-    return true;
-  }
-  const perm = o.permutation;
-  const n = perm.length;
-  for (let idx = 0; idx < n; idx++) {
-    if (perm[idx] !== idx) {
-      return false;
-    }
-  }
-  if (omod > 1) {
-    const ori = o.orientation;
-    for (let idx = 0; idx < n; idx++) {
-      if (ori[idx] !== 0) {
-        return false;
-      }
-    }
-  }
-  lasto = o;
-  return true;
-}
-
-export function combineTransformations(
-  def: KPuzzleDefinition,
-  t1: Transformation,
-  t2: Transformation,
-): Transformation {
-  const newTrans: Transformation = {} as Transformation;
-  for (const orbitName in def.orbits) {
-    const oDef = def.orbits[orbitName];
-    const o1 = t1[orbitName];
-    const o2 = t2[orbitName];
-    if (isIdentity(oDef.orientations, o2)) {
-      // common case for big cubes
-      newTrans[orbitName] = o1;
-    } else if (isIdentity(oDef.orientations, o1)) {
-      newTrans[orbitName] = o2;
-    } else {
-      const newPerm = new Array(oDef.numPieces);
-      if (oDef.orientations === 1) {
-        for (let idx = 0; idx < oDef.numPieces; idx++) {
-          newPerm[idx] = o1.permutation[o2.permutation[idx]];
-        }
-        newTrans[orbitName] = {
-          permutation: newPerm,
-          orientation: o1.orientation,
-        };
-      } else {
-        const newOri = new Array(oDef.numPieces);
-        for (let idx = 0; idx < oDef.numPieces; idx++) {
-          newOri[idx] =
-            (o1.orientation[o2.permutation[idx]] + o2.orientation[idx]) %
-            oDef.orientations;
-          newPerm[idx] = o1.permutation[o2.permutation[idx]];
-        }
-        newTrans[orbitName] = { permutation: newPerm, orientation: newOri };
-      }
-    }
-  }
-  return newTrans;
-}
-
-export function multiplyTransformations(
-  def: KPuzzleDefinition,
-  t: Transformation,
-  amount: number,
-): Transformation {
-  if (amount < 0) {
-    return multiplyTransformations(def, invertTransformation(def, t), -amount);
-  }
-  if (amount === 0) {
-    return identityTransformation(def);
-  }
-  if (amount === 1) {
-    return t;
-  }
-  let halfish = t;
-  if (amount !== 2) {
-    halfish = multiplyTransformations(def, t, Math.floor(amount / 2));
-  }
-  const twiceHalfish = combineTransformations(def, halfish, halfish);
-  if (amount % 2 === 0) {
-    return twiceHalfish;
-  } else {
-    return combineTransformations(def, t, twiceHalfish);
-  }
-}
-export function identityTransformation(
-  definition: KPuzzleDefinition,
-): Transformation {
-  const transformation = {} as Transformation;
-  for (const orbitName in definition.orbits) {
-    const orbitDefinition = definition.orbits[orbitName];
-    if (!lasto || lasto.permutation.length !== orbitDefinition.numPieces) {
-      const newPermutation = new Array(orbitDefinition.numPieces);
-      const newOrientation = new Array(orbitDefinition.numPieces);
-      for (let i = 0; i < orbitDefinition.numPieces; i++) {
-        newPermutation[i] = i;
-        newOrientation[i] = 0;
-      }
-      const orbitTransformation = {
-        permutation: newPermutation,
-        orientation: newOrientation,
-      };
-      lasto = orbitTransformation;
-      // Object.freeze(newPermutation); // TODO
-      // Object.freeze(newOrientation); // TODO
-    }
-    transformation[orbitName] = lasto;
-
-    // Object.freeze(orbitDefinition); // TODO
-  }
-  // Object.freeze(transformation); // TODO
-  return transformation;
-}
-
-export function invertTransformation(
-  def: KPuzzleDefinition,
-  t: Transformation,
-): Transformation {
-  const newTrans: Transformation = {} as Transformation;
-  for (const orbitName in def.orbits) {
-    const oDef = def.orbits[orbitName];
-    const o = t[orbitName];
-    if (isIdentity(oDef.orientations, o)) {
-      newTrans[orbitName] = o;
-    } else if (oDef.orientations === 1) {
-      const newPerm = new Array(oDef.numPieces);
-      for (let idx = 0; idx < oDef.numPieces; idx++) {
-        newPerm[o.permutation[idx]] = idx;
-      }
-      newTrans[orbitName] = {
-        permutation: newPerm,
-        orientation: o.orientation,
-      };
-    } else {
-      const newPerm = new Array(oDef.numPieces);
-      const newOri = new Array(oDef.numPieces);
-      for (let idx = 0; idx < oDef.numPieces; idx++) {
-        const fromIdx = o.permutation[idx];
-        newPerm[fromIdx] = idx;
-        newOri[fromIdx] =
-          (oDef.orientations - o.orientation[idx] + oDef.orientations) %
-          oDef.orientations;
-      }
-      newTrans[orbitName] = { permutation: newPerm, orientation: newOri };
-    }
-  }
-  return newTrans;
-}
-
-function gcd(a: number, b: number): number {
-  if (b) {
-    return gcd(b, a % b);
-  }
-  return a;
-}
-
-/* calculate the order of a particular transformation. */
-export function transformationOrder(
-  def: KPuzzleDefinition,
-  t: Transformation,
-): number {
-  let r: number = 1;
-  for (const orbitName in def.orbits) {
-    const oDef = def.orbits[orbitName];
-    const o = t[orbitName];
-    const d = new Array(oDef.numPieces);
-    for (let idx = 0; idx < oDef.numPieces; idx++) {
-      if (!d[idx]) {
-        let w = idx;
-        let om = 0;
-        let pm = 0;
-        for (;;) {
-          d[w] = true;
-          om = om + o.orientation[w];
-          pm = pm + 1;
-          w = o.permutation[w];
-          if (w === idx) {
-            break;
-          }
-        }
-        if (om !== 0) {
-          pm = (pm * oDef.orientations) / gcd(oDef.orientations, om);
-        }
-        r = (r * pm) / gcd(r, pm);
-      }
-    }
-  }
-  return r;
-}
-
-export function areOrbitTransformationsEquivalent(
-  def: KPuzzleDefinition,
-  orbitName: string,
-  t1: Transformation,
-  t2: Transformation,
-  options: {
-    ignoreOrientation?: boolean;
-    ignorePermutation?: boolean;
-  } = {},
-): boolean {
-  const oDef = def.orbits[orbitName];
-  const o1 = t1[orbitName];
-  const o2 = t2[orbitName];
-  for (let idx = 0; idx < oDef.numPieces; idx++) {
-    if (
-      !options?.ignoreOrientation &&
-      o1.orientation[idx] !== o2.orientation[idx]
-    ) {
-      return false;
-    }
-    if (
-      !options?.ignorePermutation &&
-      o1.permutation[idx] !== o2.permutation[idx]
-    ) {
-      return false;
-    }
-  }
-  return true;
-}
-
-export function areTransformationsEquivalent(
-  def: KPuzzleDefinition,
-  t1: Transformation,
-  t2: Transformation,
-): boolean {
-  for (const orbitName in def.orbits) {
-    if (!areOrbitTransformationsEquivalent(def, orbitName, t1, t2)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-export function areStatesEquivalent(
-  def: KPuzzleDefinition,
-  t1: Transformation,
-  t2: Transformation,
-): boolean {
-  // Turn transformations into states.
-  // This accounts for indistinguishable pieces.
-  return areTransformationsEquivalent(
-    def,
-    combineTransformations(def, def.startPieces, t1),
-    combineTransformations(def, def.startPieces, t2),
-  );
-}

package/src/cubing/notation/CountAnimatedLeaves.ts

@@ -1,56 +0,0 @@
-import {
-  Alg,
-  Commutator,
-  Conjugate,
-  Grouping,
-  LineComment,
-  Move,
-  Newline,
-  Pause,
-  TraversalUp,
-} from "../alg";
-
-// TODO: Include Pause, include amounts
-class CountAnimatedLeaves extends TraversalUp<number, number> {
-  public traverseAlg(alg: Alg): number {
-    let total = 0;
-    for (const part of alg.units()) {
-      total += this.traverseUnit(part);
-    }
-    return total;
-  }
-
-  public traverseGrouping(grouping: Grouping): number {
-    return this.traverseAlg(grouping.alg) * Math.abs(grouping.amount);
-  }
-
-  public traverseMove(_move: Move): number {
-    return 1;
-  }
-
-  public traverseCommutator(commutator: Commutator): number {
-    return (
-      2 * (this.traverseAlg(commutator.A) + this.traverseAlg(commutator.B))
-    );
-  }
-
-  public traverseConjugate(conjugate: Conjugate): number {
-    return 2 * this.traverseAlg(conjugate.A) + this.traverseAlg(conjugate.B);
-  }
-
-  public traversePause(_pause: Pause): number {
-    return 1;
-  }
-
-  public traverseNewline(_newline: Newline): number {
-    return 0;
-  }
-
-  public traverseLineComment(_comment: LineComment): number {
-    return 0;
-  }
-}
-
-const countAnimatedLeavesInstance = new CountAnimatedLeaves();
-export const countAnimatedLeaves: (alg: Alg) => number =
-  countAnimatedLeavesInstance.traverseAlg.bind(countAnimatedLeavesInstance);

package/src/cubing/notation/CountMoves.ts

@@ -1,89 +0,0 @@
-// TODO: move this file somewhere permanent.
-import {
-  Alg,
-  Grouping,
-  LineComment,
-  Commutator,
-  Conjugate,
-  Move,
-  Newline,
-  Pause,
-  TraversalUp,
-} from "../alg";
-
-/*
- *   For movecount, that understands puzzle rotations.  This code
- *   should be moved to the alg class, probably.
- */
-class CountMoves extends TraversalUp<number> {
-  constructor(private metric: (move: Move) => number) {
-    super();
-  }
-
-  public traverseAlg(alg: Alg): number {
-    let r = 0;
-    for (const unit of alg.units()) {
-      r += this.traverseUnit(unit);
-    }
-    return r;
-  }
-
-  public traverseGrouping(grouping: Grouping): number {
-    // const unit: Unit = Alg.fromString("SDf");
-    // console.log(unit);
-    const alg: Alg = grouping.alg;
-    return this.traverseAlg(alg) * Math.abs(grouping.amount);
-  }
-
-  public traverseMove(move: Move): number {
-    return this.metric(move);
-  }
-
-  public traverseCommutator(commutator: Commutator): number {
-    return (
-      2 * (this.traverseAlg(commutator.A) + this.traverseAlg(commutator.B))
-    );
-  }
-
-  public traverseConjugate(conjugate: Conjugate): number {
-    return 2 * this.traverseAlg(conjugate.A) + this.traverseAlg(conjugate.B);
-  }
-
-  // TODO: Remove spaces between repeated pauses (in traverseSequence)
-  public traversePause(_pause: Pause): number {
-    return 0;
-  }
-
-  public traverseNewline(_newLine: Newline): number {
-    return 0;
-  }
-
-  // TODO: Enforce being followed by a newline (or the end of the alg)?
-  public traverseLineComment(_comment: LineComment): number {
-    return 0;
-  }
-}
-
-function isCharUppercase(c: string): boolean {
-  return "A" <= c && c <= "Z";
-}
-
-// TODO: Implement a puzzle-specific way to calculate this.
-function baseMetric(move: Move): number {
-  const fam = move.family;
-  if (
-    (isCharUppercase(fam[0]) && fam[fam.length - 1] === "v") ||
-    fam === "x" ||
-    fam === "y" ||
-    fam === "z" ||
-    fam === "T"
-  ) {
-    return 0;
-  } else {
-    return 1;
-  }
-}
-
-const countMovesInstance = new CountMoves(baseMetric);
-export const countMoves: (alg: Alg) => number =
-  countMovesInstance.traverseAlg.bind(countMovesInstance);

package/src/cubing/notation/index.ts

@@ -1,4 +0,0 @@
-// Note: this folder is purposely not built as a package entry point (yet).
-
-export { countMoves } from "./CountMoves";
-export { countAnimatedLeaves } from "./CountAnimatedLeaves";

package/src/cubing/protocol/binary/binary3x3x3.spec.ts

@@ -1,143 +0,0 @@
-import { Alg } from "../../alg";
-import {
-  KPuzzle,
-  Transformation,
-  experimentalCube3x3x3KPuzzle as def,
-} from "../../kpuzzle";
-import {
-  reid3x3x3ToTwizzleBinary,
-  twizzleBinaryToReid3x3x3,
-} from "./binary3x3x3";
-import { bufferToSpacedHex } from "./hex";
-
-function stateForAlg(alg: string): Transformation {
-  const kpuzzle = new KPuzzle(def);
-  kpuzzle.applyAlg(new Alg(alg));
-  return kpuzzle.state;
-}
-
-describe("Binary 3x3x3", () => {
-  it("converts to binary", () => {
-    expect(reid3x3x3ToTwizzleBinary(stateForAlg(""))).toEqual(
-      new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0]),
-    );
-
-    // Superflip (without center rotation)
-    expect(
-      reid3x3x3ToTwizzleBinary(stateForAlg("((M' U')4 [U2, M' E2 M] x y)3")),
-    ).toEqual(new Uint8Array([0, 0, 0, 7, 255, 128, 0, 0, 0, 16, 0]));
-
-    // Simple superflip (with center rotation)
-    expect(reid3x3x3ToTwizzleBinary(stateForAlg("((M' U')4 x y)3"))).toEqual(
-      new Uint8Array([0, 0, 0, 7, 255, 128, 0, 0, 0, 26, 170]),
-    );
-
-    // Swap last 2 edges and last 2 corner
-    expect(
-      reid3x3x3ToTwizzleBinary(
-        stateForAlg("L2 F2 U' R2 U F2 L2 D2 L2 D2 L2 U B2 D B2 U'"),
-      ),
-    ).toEqual(new Uint8Array([0, 0, 0, 8, 0, 0, 0, 128, 0, 16, 33]));
-
-    // Rotate top center 180°
-    expect(reid3x3x3ToTwizzleBinary(stateForAlg("(R' U' R U')5"))).toEqual(
-      new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0]),
-    );
-
-    // CO
-    expect(
-      reid3x3x3ToTwizzleBinary(
-        stateForAlg("(L U L' U L U2 L' R' U' R U' R' U2' R z)4"),
-      ),
-    ).toEqual(new Uint8Array([0, 0, 0, 0, 0, 0, 0, 66, 128, 16, 0]));
-  });
-
-  it("handles rotations", () => {
-    expect(reid3x3x3ToTwizzleBinary(stateForAlg("z y"))).toEqual(
-      new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 176, 0]),
-    );
-
-    expect(reid3x3x3ToTwizzleBinary(stateForAlg("x2 z'"))).toEqual(
-      new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 240, 0]),
-    );
-  });
-
-  it("validates", () => {
-    expect(() => {
-      twizzleBinaryToReid3x3x3(
-        new Uint8Array([255, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0]),
-      );
-    }).toThrow("epLex (534773760) out of range");
-
-    // Requires MO support for now.
-    expect(() => {
-      twizzleBinaryToReid3x3x3(
-        new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
-      );
-    }).toThrow();
-
-    expect(() => {
-      // 0x111 (idxU)
-      twizzleBinaryToReid3x3x3(
-        new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 3, 144, 0]),
-      );
-    }).not.toThrow();
-
-    expect(() => {
-      twizzleBinaryToReid3x3x3(
-        new Uint8Array([255, 0, 0, 0, 0, 127, 0, 0, 0, 16, 0]),
-      );
-    }).toThrow("epLex (534773760) out of range, cpLex (65024) out of range");
-  });
-
-  it("round-trips 3.47 WR scramble", () => {
-    const state = stateForAlg("F U2 L2 B2 F' U L2 U R2 D2 L' B L2 B' R2 U2");
-    expect(twizzleBinaryToReid3x3x3(reid3x3x3ToTwizzleBinary(state))).toEqual(
-      state,
-    );
-  });
-
-  it("round-trips 7.08 WR scramble", () => {
-    const state = stateForAlg(
-      "D' R2 D L2 B2 L2 D' R2 F' L2 R' F D F' D' L' U2 F' R",
-    );
-    expect(twizzleBinaryToReid3x3x3(reid3x3x3ToTwizzleBinary(state))).toEqual(
-      state,
-    );
-  });
-
-  it("round-trips 7.08 WR scramble with extra orientation", () => {
-    const state = stateForAlg(
-      "x D' R2 D L2 B2 L2 D' R2 F' L2 R' F D F' D' L' U2 F' R y",
-    );
-    expect(state["CENTERS"].permutation).toEqual([2, 5, 3, 0, 1, 4]);
-    expect(twizzleBinaryToReid3x3x3(reid3x3x3ToTwizzleBinary(state))).toEqual(
-      state,
-    );
-  });
-});
-
-describe("puzzle orientation", () => {
-  it("doesn't affect encoded permutation (relative to centers)", () => {
-    const state = stateForAlg(
-      "D' R2 D L2 B2 L2 D' R2 F' L2 R' F D F' D' L' U2 F' R",
-    );
-    expect(state["CENTERS"].permutation).toEqual([0, 1, 2, 3, 4, 5]);
-    const rotatedState = stateForAlg(
-      "D' R2 D L2 B2 L2 D' R2 F' L2 R' F D F' D' L' U2 F' R x y",
-    );
-    expect(rotatedState["CENTERS"].permutation).toEqual([2, 5, 3, 0, 1, 4]);
-    const buffy = new Uint8Array(reid3x3x3ToTwizzleBinary(rotatedState));
-    buffy[8] ^= 0b00000001;
-    buffy[9] ^= 0b01100000;
-    expect(twizzleBinaryToReid3x3x3(buffy)).toEqual(state);
-  });
-});
-
-describe("Hex", () => {
-  it("conversion works", () => {
-    expect(bufferToSpacedHex(reid3x3x3ToTwizzleBinary(stateForAlg("")))).toBe(
-      "00 00 00 00 00 00 00 00 00 10 00",
-    );
-  });
-});