cubing 0.22.0 → 0.24.0-pre2

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

@@ -1,226 +0,0 @@
-import type { Transformation } from "../../kpuzzle";
-import {
-  identityPermutation,
-  lexToPermutation,
-  maskToOrientations,
-  orientationsToMask,
-  permutationToLex,
-} from "./orbit-indexing";
-import {
-  normalizePuzzleOrientation,
-  puzzleOrientationIdx,
-  reorientPuzzle,
-} from "./puzzle-orientation";
-
-type Binary3x3x3State = ArrayBuffer;
-
-// Bit lengths of the encoded components, in order.
-const BIT_LENGTHS = [29, 12, 16, 13, 3, 2, 1, 12];
-
-// These fields are sorted by the order in which they appear in the binary format.
-export interface Binary3x3x3Components {
-  epLex: number; // 29 bits, edge permutation
-  eoMask: number; // 12 bits, edge orientation
-  cpLex: number; // 16 bits, corner permutation
-  coMask: number; // 13 bits, corner orientation
-  poIdxU: number; // 3 bits, puzzle orientation (U face)
-  poIdxL: number; // 2 bits, puzzle orientation (L face)
-  moSupport: number; // 1 bit, center orientation support
-  moMask: number; // 12 bits, center orientation
-}
-
-// There are various clever ways to do this, but this is simple and efficient.
-function arraySum(arr: number[]): number {
-  let total = 0;
-  for (const entry of arr) {
-    total += entry;
-  }
-  return total;
-}
-
-// Due to limitations in JS bit operations, this is unsafe if any of the bit lengths span across the contents of more than 4 bytes.
-// - Safe: [8, 32]
-// - Unsafe: [4, 32, 4]
-// - Unsafe: [40, 4]
-function splitBinary(bitLengths: number[], buffy: ArrayBuffer): number[] {
-  const u8buffy = new Uint8Array(buffy);
-  let at = 0;
-  let bits = 0;
-  let accum = 0;
-  const values: number[] = [];
-  for (const bitLength of bitLengths) {
-    while (bits < bitLength) {
-      accum = (accum << 8) | u8buffy[at++];
-      bits += 8;
-    }
-    values.push((accum >> (bits - bitLength)) & ((1 << bitLength) - 1));
-    bits -= bitLength;
-  }
-  return values;
-}
-
-// See above for safety notes.
-function concatBinary(bitLengths: number[], values: number[]): ArrayBuffer {
-  const buffy = new Uint8Array(Math.ceil(arraySum(bitLengths) / 8));
-  let at = 0;
-  let bits = 0;
-  let accum = 0;
-  for (let i = 0; i < bitLengths.length; i++) {
-    accum = (accum << bitLengths[i]) | values[i];
-    bits += bitLengths[i];
-    while (bits >= 8) {
-      buffy[at++] = accum >> (bits - 8);
-      bits -= 8;
-    }
-  }
-  if (bits > 0) {
-    buffy[at++] = accum << (8 - bits);
-  }
-  return buffy;
-}
-
-// 0x111 (for idxU) means "not supported"
-function supportsPuzzleOrientation(components: Binary3x3x3Components): boolean {
-  return components.poIdxU !== 7;
-}
-
-export function reid3x3x3ToBinaryComponents(
-  state: Transformation,
-): Binary3x3x3Components {
-  const normedState = normalizePuzzleOrientation(state);
-
-  const epLex = permutationToLex(normedState["EDGES"].permutation);
-  const eoMask = orientationsToMask(2, normedState["EDGES"].orientation);
-  const cpLex = permutationToLex(normedState["CORNERS"].permutation);
-  const coMask = orientationsToMask(3, normedState["CORNERS"].orientation);
-  const [poIdxU, poIdxL] = puzzleOrientationIdx(state);
-  const moSupport = 1; // Required for now.
-  const moMask = orientationsToMask(4, normedState["CENTERS"].orientation);
-
-  return {
-    epLex,
-    eoMask,
-    cpLex,
-    coMask,
-    poIdxU,
-    poIdxL,
-    moSupport,
-    moMask,
-  };
-}
-
-export function binaryComponentsToTwizzleBinary(
-  components: Binary3x3x3Components,
-): Binary3x3x3State {
-  const { epLex, eoMask, cpLex, coMask, poIdxU, poIdxL, moSupport, moMask } =
-    components;
-
-  return concatBinary(BIT_LENGTHS, [
-    epLex,
-    eoMask,
-    cpLex,
-    coMask,
-    poIdxU,
-    poIdxL,
-    moSupport,
-    moMask,
-  ]);
-}
-
-export function reid3x3x3ToTwizzleBinary(
-  state: Transformation,
-): Binary3x3x3State {
-  const components: Binary3x3x3Components = reid3x3x3ToBinaryComponents(state);
-  return binaryComponentsToTwizzleBinary(components);
-}
-
-export function twizzleBinaryToBinaryComponents(
-  buffer: ArrayBuffer,
-): Binary3x3x3Components {
-  const [epLex, eoMask, cpLex, coMask, poIdxU, poIdxL, moSupport, moMask] =
-    splitBinary(BIT_LENGTHS, buffer);
-
-  return {
-    epLex,
-    eoMask,
-    cpLex,
-    coMask,
-    poIdxU,
-    poIdxL,
-    moSupport,
-    moMask,
-  };
-}
-
-export function binaryComponentsToReid3x3x3(
-  components: Binary3x3x3Components,
-): Transformation {
-  if (components.moSupport !== 1) {
-    throw new Error("Must support center orientation.");
-  }
-
-  const normedState = {
-    EDGES: {
-      permutation: lexToPermutation(12, components.epLex),
-      orientation: maskToOrientations(2, 12, components.eoMask),
-    },
-    CORNERS: {
-      permutation: lexToPermutation(8, components.cpLex),
-      orientation: maskToOrientations(3, 8, components.coMask),
-    },
-    CENTERS: {
-      permutation: identityPermutation(6),
-      orientation: maskToOrientations(4, 6, components.moMask),
-    },
-  };
-
-  if (!supportsPuzzleOrientation(components)) {
-    return normedState;
-  }
-
-  return reorientPuzzle(normedState, components.poIdxU, components.poIdxL);
-}
-
-// Returns a list of error string.
-// An empty list means validation success.
-function validateComponents(components: Binary3x3x3Components): string[] {
-  const errors = [];
-  if (components.epLex < 0 || components.epLex >= 479001600) {
-    errors.push(`epLex (${components.epLex}) out of range`);
-  }
-  if (components.cpLex < 0 || components.cpLex >= 40320) {
-    errors.push(`cpLex (${components.cpLex}) out of range`);
-  }
-  if (components.coMask < 0 || components.coMask >= 6561) {
-    errors.push(`coMask (${components.coMask}) out of range`);
-  }
-  if (components.poIdxU < 0 || components.poIdxU >= 6) {
-    // 0x111 (for idxU) means "not supported"
-    if (supportsPuzzleOrientation(components)) {
-      errors.push(`poIdxU (${components.poIdxU}) out of range`);
-    }
-  }
-  // The following cannot be (f decoded from binary properl) out of rangey.
-  if (components.eoMask < 0 || components.eoMask >= 4096) {
-    errors.push(`eoMask (${components.eoMask}) out of range`);
-  }
-  if (components.moMask < 0 || components.moMask >= 4096) {
-    errors.push(`moMask (${components.moMask}) out of range`);
-  }
-  if (components.poIdxL < 0 || components.poIdxL >= 4) {
-    errors.push(`poIdxL (${components.poIdxL}) out of range`);
-  }
-  if (components.moSupport < 0 || components.moSupport >= 2) {
-    errors.push(`moSupport (${components.moSupport}) out of range`);
-  }
-  return errors;
-}
-
-export function twizzleBinaryToReid3x3x3(buffy: ArrayBuffer): Transformation {
-  const components = twizzleBinaryToBinaryComponents(buffy);
-  const errors = validateComponents(components);
-  if (errors.length !== 0) {
-    throw new Error(`Invalid binary state components: ${errors.join(", ")}`);
-  }
-  return binaryComponentsToReid3x3x3(components);
-}

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

@@ -1,17 +0,0 @@
-import { bufferToSpacedHex, spacedHexToBuffer } from "./hex";
-
-describe("hex", () => {
-  it("converts to hex", () => {
-    expect(
-      bufferToSpacedHex(
-        new Uint8Array([0, 0, 0, 0, 32, 0, 0, 0, 255, 250, 170]),
-      ),
-    ).toBe("00 00 00 00 20 00 00 00 ff fa aa");
-  });
-
-  it("converts to buffer", () => {
-    expect(spacedHexToBuffer("00 00 00 00 20 00 00 00 ff fa aa")).toEqual(
-      new Uint8Array([0, 0, 0, 0, 32, 0, 0, 0, 255, 250, 170]),
-    );
-  });
-});

package/src/cubing/protocol/binary/hex.ts

@@ -1,12 +0,0 @@
-export function bufferToSpacedHex(buffer: ArrayBuffer): string {
-  // buffer is an ArrayBuffer
-  return (
-    Array.prototype.map.call(new Uint8Array(buffer), (x: number) =>
-      ("00" + x.toString(16)).slice(-2),
-    ) as string[]
-  ).join(" ");
-}
-
-export function spacedHexToBuffer(hex: string): Uint8Array {
-  return new Uint8Array(hex.split(" ").map((c) => parseInt(c, 16)));
-}

package/src/cubing/protocol/binary/orbit-indexing.spec.ts

@@ -1,49 +0,0 @@
-import {
-  permutationToLex,
-  lexToPermutation,
-  orientationsToMask,
-  maskToOrientations,
-} from "./orbit-indexing";
-
-describe("orbit indexing", () => {
-  it("indexes", () => {
-    expect(permutationToLex([0, 1, 2])).toBe(0);
-    expect(permutationToLex([0, 2, 1])).toBe(1);
-    expect(permutationToLex([2, 0, 1])).toBe(4);
-    expect(permutationToLex([0, 1, 2, 3, 4, 5])).toBe(0);
-    expect(permutationToLex([5, 4, 3, 2, 1, 0])).toBe(719);
-  });
-
-  it("un-indexes", () => {
-    expect(lexToPermutation(3, 0)).toEqual([0, 1, 2]);
-    expect(lexToPermutation(3, 1)).toEqual([0, 2, 1]);
-    expect(lexToPermutation(3, 4)).toEqual([2, 0, 1]);
-    expect(lexToPermutation(6, 0)).toEqual([0, 1, 2, 3, 4, 5]);
-    expect(lexToPermutation(6, 719)).toEqual([5, 4, 3, 2, 1, 0]);
-  });
-
-  it("orients", () => {
-    expect(orientationsToMask(2, [1, 0, 0, 1, 0, 1, 1, 0])).toEqual(0b10010110);
-  });
-});
-
-describe("orientationRangeToMask", () => {
-  it("converts to mask correctly", () => {
-    expect(orientationsToMask(2, [0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1])).toBe(
-      1217,
-    );
-  });
-  it("converts from mask correctly", () => {
-    expect(maskToOrientations(2, 12, 1217)).toEqual([
-      0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1,
-    ]);
-  });
-  it("round-trips", () => {
-    expect(
-      maskToOrientations(3, 4, orientationsToMask(3, [2, 0, 2, 1])),
-    ).toEqual([2, 0, 2, 1]);
-    expect(
-      maskToOrientations(4, 6, orientationsToMask(4, [2, 1, 0, 3, 2, 2])),
-    ).toEqual([2, 1, 0, 3, 2, 2]);
-  });
-});

package/src/cubing/protocol/binary/orbit-indexing.ts

@@ -1,68 +0,0 @@
-export function identityPermutation(numElems: number): number[] {
-  const arr = new Array<number>(numElems);
-  for (let i = 0; i < numElems; i++) {
-    arr[i] = i;
-  }
-  return arr;
-}
-
-// Inclusive start, exclusive end (similar to `Array.prototype.slice`)
-export function orientationsToMask(
-  radix: number,
-  orientations: number[],
-): number {
-  let val = 0;
-  for (const orientation of orientations) {
-    val *= radix;
-    val += orientation;
-  }
-  return val;
-}
-
-// Inclusive start, exclusive end (similar to `Array.prototype.slice`)
-export function maskToOrientations(
-  radix: number,
-  numElems: number,
-  mask: number,
-): number[] {
-  const arr = [];
-  while (mask > 0) {
-    arr.push(mask % radix);
-    mask = Math.floor(mask / radix);
-  }
-  return new Array<number>(numElems - arr.length).fill(0).concat(arr.reverse());
-}
-
-// From https://www.jaapsch.net/puzzles/compindx.htm#perm
-export function permutationToLex(permutation: number[]): number {
-  const n = permutation.length;
-  let lexicographicIdx = 0;
-  for (let i = 0; i < n - 1; i++) {
-    lexicographicIdx = lexicographicIdx * (n - i);
-    for (let j = i + 1; j < n; j++) {
-      if (permutation[i] > permutation[j]) {
-        lexicographicIdx += 1;
-      }
-    }
-  }
-  return lexicographicIdx;
-}
-
-// From https://www.jaapsch.net/puzzles/compindx.htm#perm
-export function lexToPermutation(
-  numPieces: number,
-  lexicographicIdx: number,
-): number[] {
-  const permutation: number[] = new Array(numPieces);
-  permutation[numPieces - 1] = 0;
-  for (let i = numPieces - 2; i >= 0; i--) {
-    permutation[i] = lexicographicIdx % (numPieces - i);
-    lexicographicIdx = Math.floor(lexicographicIdx / (numPieces - i));
-    for (let j = i + 1; j < numPieces; j++) {
-      if (permutation[j] >= permutation[i]) {
-        permutation[j] = permutation[j] + 1;
-      }
-    }
-  }
-  return permutation;
-}

package/src/cubing/protocol/binary/puzzle-orientation.ts

@@ -1,69 +0,0 @@
-import { Alg } from "../../alg";
-import {
-  combineTransformations,
-  invertTransformation,
-  KPuzzle,
-  Transformation,
-} from "../../kpuzzle";
-// TODO: Should we expose this directly in the `puzzles` package for sync uses?
-import { experimentalCube3x3x3KPuzzle as def } from "../../kpuzzle";
-
-export function puzzleOrientationIdx(state: Transformation): [number, number] {
-  const idxU = state["CENTERS"].permutation[0];
-  const idxD = state["CENTERS"].permutation[5];
-  const unadjustedIdxL = state["CENTERS"].permutation[1];
-  let idxL = unadjustedIdxL;
-  if (idxU < unadjustedIdxL) {
-    idxL--;
-  }
-  if (idxD < unadjustedIdxL) {
-    idxL--;
-  }
-  return [idxU, idxL];
-}
-
-const puzzleOrientationCache: Transformation[][] = new Array(6)
-  .fill(0)
-  .map(() => {
-    return new Array<Transformation>(6);
-  });
-
-// We use a new block to avoid keeping a reference to temporary vars.
-{
-  const orientationKpuzzle = new KPuzzle(def);
-  const uAlgs: Alg[] = ["", "z", "x", "z'", "x'", "x2"].map((s) =>
-    Alg.fromString(s),
-  );
-  const yAlg = new Alg("y");
-  for (const uAlg of uAlgs) {
-    orientationKpuzzle.reset();
-    orientationKpuzzle.applyAlg(uAlg);
-    for (let i = 0; i < 4; i++) {
-      orientationKpuzzle.applyAlg(yAlg);
-      const [idxU, idxL] = puzzleOrientationIdx(orientationKpuzzle.state);
-      puzzleOrientationCache[idxU][idxL] = invertTransformation(
-        def,
-        orientationKpuzzle.state,
-      );
-    }
-  }
-}
-
-export function normalizePuzzleOrientation(s: Transformation): Transformation {
-  const [idxU, idxL] = puzzleOrientationIdx(s);
-  const orientationTransformation = puzzleOrientationCache[idxU][idxL];
-  return combineTransformations(def, s, orientationTransformation);
-}
-
-// TODO: combine with `orientPuzzle`?
-export function reorientPuzzle(
-  s: Transformation,
-  idxU: number,
-  idxL: number,
-): Transformation {
-  const orientationTransformation = invertTransformation(
-    def,
-    puzzleOrientationCache[idxU][idxL],
-  );
-  return combineTransformations(def, s, orientationTransformation);
-}

package/src/cubing/protocol/index.ts

@@ -1,12 +0,0 @@
-export {
-  reid3x3x3ToTwizzleBinary,
-  twizzleBinaryToReid3x3x3,
-} from "./binary/binary3x3x3";
-export { bufferToSpacedHex, spacedHexToBuffer } from "./binary/hex";
-
-export { normalizePuzzleOrientation as experimentalNormalizePuzzleOrientation } from "./binary/puzzle-orientation";
-
-export {
-  binaryComponentsToReid3x3x3 as experimentalBinaryComponentsToReid3x3x3,
-  twizzleBinaryToBinaryComponents as experimentalTwizzleBinaryToBinaryComponents,
-} from "./binary/binary3x3x3";

package/src/cubing/puzzle-geometry/FaceNameSwizzler.ts

@@ -1,148 +0,0 @@
-// Manages a set of face names.  Detects whether they are prefix-free.
-// Implements greedy splitting into face names and comparisons between
-// concatenated face names and grip names.
-
-export class FaceNameSwizzler {
-  public prefixFree: boolean = true;
-  public gripnames: string[] = [];
-  constructor(public facenames: string[], gripnames_arg?: string[]) {
-    if (gripnames_arg) {
-      this.gripnames = gripnames_arg;
-    }
-    for (let i = 0; this.prefixFree && i < facenames.length; i++) {
-      for (let j = 0; this.prefixFree && j < facenames.length; j++) {
-        if (i !== j && facenames[i].startsWith(facenames[j])) {
-          this.prefixFree = false;
-        }
-      }
-    }
-  }
-
-  public setGripNames(names: string[]): void {
-    this.gripnames = names;
-  }
-
-  // split a string into face names and return a list of
-  // indices.
-  public splitByFaceNames(s: string): number[] {
-    const r = [];
-    let at = 0;
-    while (at < s.length) {
-      if (at > 0 && at < s.length && s[at] === "_") {
-        at++;
-      }
-      let currentMatch = -1;
-      for (let i = 0; i < this.facenames.length; i++) {
-        if (
-          s.substr(at).startsWith(this.facenames[i]) &&
-          (currentMatch < 0 ||
-            this.facenames[i].length > this.facenames[currentMatch].length)
-        ) {
-          currentMatch = i;
-        }
-      }
-      if (currentMatch >= 0) {
-        r.push(currentMatch);
-        at += this.facenames[currentMatch].length;
-      } else {
-        throw new Error("Could not split " + s + " into face names.");
-      }
-    }
-    return r;
-  }
-
-  // cons a grip from an array of numbers.
-  public joinByFaceIndices(list: number[]): string {
-    let sep = "";
-    const r = [];
-    for (let i = 0; i < list.length; i++) {
-      r.push(sep);
-      r.push(this.facenames[list[i]]);
-      if (!this.prefixFree) {
-        sep = "_";
-      }
-    }
-    return r.join("");
-  }
-
-  /*
-   *   Try to match something the user gave us with some geometric
-   *   feature.  We used to have strict requirements:
-   *
-   *      a)  The set of face names are prefix free
-   *      b)  When specifying a corner, all coincident planes were
-   *          specified
-   *
-   *   But, to allow megaminx to have more reasonable and
-   *   conventional names, and to permit shorter canonical
-   *   names, we are relaxing these requirements and adding
-   *   new syntax.  Now:
-   *
-   *      a)  Face names need not be syntax free.
-   *      b)  When parsing a geometric name, we use greedy
-   *          matching, so the longest name that matches the
-   *          user string at the current position is the one
-   *          assumed to match.
-   *      c)  Underscores are permitted to separate face names
-   *          (both in user input and in geometric
-   *          descriptions).
-   *      d)  Default names of corner moves where corners have
-   *          more than three corners, need only include three
-   *          of the corners.
-   *
-   *   This code is not performance-sensitive so we can do it a
-   *   slow and simple way.
-   */
-  public spinmatch(userinput: string, longname: string): boolean {
-    // are these the same rotationally?
-    if (userinput === longname) {
-      return true;
-    }
-    try {
-      const e1 = this.splitByFaceNames(userinput);
-      const e2 = this.splitByFaceNames(longname);
-      // All elements of userinput need to be in the longname.
-      // There should be no duplicate elements in the userinput.
-      // if both have length 1 or length 2, the sets must be equal.
-      // if both have length 3 or more, then the first set must be
-      // a subset of the second.  Order doesn't matter.
-      if (e1.length !== e2.length && e1.length < 3) {
-        return false;
-      }
-      for (let i = 0; i < e1.length; i++) {
-        for (let j = 0; j < i; j++) {
-          if (e1[i] === e1[j]) {
-            return false;
-          }
-        }
-        let found = false;
-        for (let j = 0; j < e2.length; j++) {
-          if (e1[i] === e2[j]) {
-            found = true;
-            break;
-          }
-        }
-        if (!found) {
-          return false;
-        }
-      }
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  public unswizzle(s: string): string {
-    if ((s.endsWith("v") || s.endsWith("w")) && s[0] <= "Z") {
-      s = s.slice(0, s.length - 1);
-    }
-    const upperCaseGrip = s.toUpperCase();
-    for (let i = 0; i < this.gripnames.length; i++) {
-      const g = this.gripnames[i];
-      if (this.spinmatch(upperCaseGrip, g)) {
-        return g;
-      }
-    }
-    return s;
-  }
-}