cubing 0.22.0 → 0.24.0-pre2

package/src/cubing/puzzle-geometry/Quat.spec.ts

@@ -1,10 +0,0 @@
-import { Quat } from "./Quat";
-
-describe("Quat", () => {
-  it("should multiply", () => {
-    const a = new Quat(3, 1, 4, 1);
-    const b = new Quat(5, 9, 2, 6);
-    const c = a.mul(b);
-    expect(c.dist(new Quat(-8, 54, 29, -11))).toBe(0);
-  });
-});

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

@@ -1,325 +0,0 @@
-/* tslint:disable no-bitwise */
-/* tslint:disable prefer-for-of */ // TODO
-
-// We need a quaternion class.  We use this to represent rotations,
-// planes, and points.
-
-const eps = 1e-9; // TODO: Deduplicate with `PuzzleGeometry`?
-
-export function centermassface(face: Quat[]): Quat {
-  // calculate a center of a face by averaging points
-  let s = new Quat(0, 0, 0, 0);
-  for (let i = 0; i < face.length; i++) {
-    s = s.sum(face[i]);
-  }
-  return s.smul(1.0 / face.length);
-}
-
-export function solvethreeplanes(
-  p1: number,
-  p2: number,
-  p3: number,
-  planes: Quat[],
-): any {
-  // find intersection of three planes but only if interior
-  // Takes three indices into a plane array, and returns the point at the
-  // intersection of all three, but only if it is internal to all planes.
-  const p = planes[p1].intersect3(planes[p2], planes[p3]);
-  if (!p) {
-    return p;
-  }
-  for (let i = 0; i < planes.length; i++) {
-    if (i !== p1 && i !== p2 && i !== p3) {
-      const dt = planes[i].b * p.b + planes[i].c * p.c + planes[i].d * p.d;
-      if (
-        (planes[i].a > 0 && dt > planes[i].a) ||
-        (planes[i].a < 0 && dt < planes[i].a)
-      ) {
-        return false;
-      }
-    }
-  }
-  return p;
-}
-
-export class Quat {
-  constructor(
-    public a: number,
-    public b: number,
-    public c: number,
-    public d: number,
-  ) {}
-
-  public mul(q: Quat): Quat {
-    // Quaternion multiplication
-    return new Quat(
-      this.a * q.a - this.b * q.b - this.c * q.c - this.d * q.d,
-      this.a * q.b + this.b * q.a + this.c * q.d - this.d * q.c,
-      this.a * q.c - this.b * q.d + this.c * q.a + this.d * q.b,
-      this.a * q.d + this.b * q.c - this.c * q.b + this.d * q.a,
-    );
-  }
-
-  public toString(): string {
-    return `Q[${this.a},${this.b},${this.c},${this.d}]`;
-  }
-
-  public dist(q: Quat): number {
-    // Euclidean distance
-    return Math.hypot(this.a - q.a, this.b - q.b, this.c - q.c, this.d - q.d);
-  }
-
-  public len(): number {
-    // Euclidean length
-    return Math.hypot(this.a, this.b, this.c, this.d);
-  }
-
-  public cross(q: Quat): Quat {
-    // cross product
-    return new Quat(
-      0,
-      this.c * q.d - this.d * q.c,
-      this.d * q.b - this.b * q.d,
-      this.b * q.c - this.c * q.b,
-    );
-  }
-
-  public dot(q: Quat): number {
-    // dot product of two quaternions
-    return this.b * q.b + this.c * q.c + this.d * q.d;
-  }
-
-  public normalize(): Quat {
-    // make the magnitude be 1
-    const d = Math.sqrt(this.dot(this));
-    return new Quat(this.a / d, this.b / d, this.c / d, this.d / d);
-  }
-
-  public makenormal(): Quat {
-    // make a normal vector from a plane or quat or point
-    return new Quat(0, this.b, this.c, this.d).normalize();
-  }
-
-  public normalizeplane(): Quat {
-    // normalize a plane
-    const d = Math.hypot(this.b, this.c, this.d);
-    return new Quat(this.a / d, this.b / d, this.c / d, this.d / d);
-  }
-
-  public smul(m: number): Quat {
-    // scalar multiplication
-    return new Quat(this.a * m, this.b * m, this.c * m, this.d * m);
-  }
-
-  public sum(q: Quat): Quat {
-    // quaternion sum
-    return new Quat(this.a + q.a, this.b + q.b, this.c + q.c, this.d + q.d);
-  }
-
-  public sub(q: Quat): Quat {
-    // difference
-    return new Quat(this.a - q.a, this.b - q.b, this.c - q.c, this.d - q.d);
-  }
-
-  public angle(): number {
-    // quaternion angle
-    return 2 * Math.acos(this.a);
-  }
-
-  public invrot(): Quat {
-    // quaternion inverse rotation
-    return new Quat(this.a, -this.b, -this.c, -this.d);
-  }
-
-  public det3x3(
-    a00: number,
-    a01: number,
-    a02: number,
-    a10: number,
-    a11: number,
-    a12: number,
-    a20: number,
-    a21: number,
-    a22: number,
-  ): number {
-    // 3x3 determinant
-    return (
-      a00 * (a11 * a22 - a12 * a21) +
-      a01 * (a12 * a20 - a10 * a22) +
-      a02 * (a10 * a21 - a11 * a20)
-    );
-  }
-
-  public rotateplane(q: Quat): Quat {
-    // rotate a plane using a quaternion
-    const t = q.mul(new Quat(0, this.b, this.c, this.d)).mul(q.invrot());
-    t.a = this.a;
-    return t;
-  }
-
-  // return any vector orthogonal to the given one.  Find the smallest
-  // component (in absolute value) and return the cross product of that
-  // axis with the given vector.
-  public orthogonal(): Quat {
-    const ab = Math.abs(this.b);
-    const ac = Math.abs(this.c);
-    const ad = Math.abs(this.d);
-    if (ab < ac && ab < ad) {
-      return this.cross(new Quat(0, 1, 0, 0)).normalize();
-    } else if (ac < ab && ac < ad) {
-      return this.cross(new Quat(0, 0, 1, 0)).normalize();
-    } else {
-      return this.cross(new Quat(0, 0, 0, 1)).normalize();
-    }
-  }
-
-  // return the Quaternion that will rotate the this vector
-  // to the b vector through rotatepoint.
-  public pointrotation(b: Quat): Quat {
-    const a = this.normalize();
-    b = b.normalize();
-    if (a.sub(b).len() < eps) {
-      return new Quat(1, 0, 0, 0);
-    }
-    let h = a.sum(b);
-    if (h.len() < eps) {
-      h = h.orthogonal();
-    } else {
-      h = h.normalize();
-    }
-    const r = a.cross(h);
-    r.a = a.dot(h);
-    return r;
-  }
-
-  // given two vectors, return the portion of the first that
-  // is not in the direction of the second.
-  public unproject(b: Quat): Quat {
-    return this.sum(b.smul(-this.dot(b) / (this.len() * b.len())));
-  }
-
-  public rotatepoint(q: Quat): Quat {
-    // rotate a point
-    return q.mul(this).mul(q.invrot());
-  }
-
-  public rotateface(face: Quat[]): Quat[] {
-    // rotate a face by this Q.
-    return face.map((_: Quat) => _.rotatepoint(this));
-  }
-
-  public intersect3(p2: Quat, p3: Quat): Quat | false {
-    // intersect three planes if there is one
-    const det = this.det3x3(
-      this.b,
-      this.c,
-      this.d,
-      p2.b,
-      p2.c,
-      p2.d,
-      p3.b,
-      p3.c,
-      p3.d,
-    );
-    if (Math.abs(det) < eps) {
-      return false; // TODO: Change to `null` or `undefined`?
-    }
-    return new Quat(
-      0,
-      this.det3x3(this.a, this.c, this.d, p2.a, p2.c, p2.d, p3.a, p3.c, p3.d) /
-        det,
-      this.det3x3(this.b, this.a, this.d, p2.b, p2.a, p2.d, p3.b, p3.a, p3.d) /
-        det,
-      this.det3x3(this.b, this.c, this.a, p2.b, p2.c, p2.a, p3.b, p3.c, p3.a) /
-        det,
-    );
-  }
-
-  public side(x: number): number {
-    // is this point close to the origin, or on one or the other side?
-    if (x > eps) {
-      return 1;
-    }
-    if (x < -eps) {
-      return -1;
-    }
-    return 0;
-  }
-
-  /**
-   * Cuts a face by this plane, or returns null if there
-   * is no intersection.
-   * @param face The face to cut.
-   */
-  public cutface(face: Quat[]): Quat[][] | null {
-    const d = this.a;
-    let seen = 0;
-    let r = null;
-    for (let i = 0; i < face.length; i++) {
-      seen |= 1 << (this.side(face[i].dot(this) - d) + 1);
-    }
-    if ((seen & 5) === 5) {
-      r = [];
-      // saw both sides
-      const inout = face.map((_: Quat) => this.side(_.dot(this) - d));
-      for (let s = -1; s <= 1; s += 2) {
-        const nface = [];
-        for (let k = 0; k < face.length; k++) {
-          if (inout[k] === s || inout[k] === 0) {
-            nface.push(face[k]);
-          }
-          const kk = (k + 1) % face.length;
-          if (inout[k] + inout[kk] === 0 && inout[k] !== 0) {
-            const vk = face[k].dot(this) - d;
-            const vkk = face[kk].dot(this) - d;
-            const r = vk / (vk - vkk);
-            const pt = face[k].smul(1 - r).sum(face[kk].smul(r));
-            nface.push(pt);
-          }
-        }
-        r.push(nface);
-      }
-    }
-    return r;
-  }
-
-  public cutfaces(faces: Quat[][]): Quat[][] {
-    // Cut a set of faces by a plane and return new set
-    const nfaces = [];
-    for (let j = 0; j < faces.length; j++) {
-      const face = faces[j];
-      const t = this.cutface(face);
-      if (t) {
-        nfaces.push(t[0]);
-        nfaces.push(t[1]);
-      } else {
-        nfaces.push(face);
-      }
-    }
-    return nfaces;
-  }
-
-  public faceside(face: Quat[]): number {
-    // which side of a plane is a face on?
-    const d = this.a;
-    for (let i = 0; i < face.length; i++) {
-      const s = this.side(face[i].dot(this) - d);
-      if (s !== 0) {
-        return s;
-      }
-    }
-    throw new Error("Could not determine side of plane in faceside");
-  }
-
-  public sameplane(p: Quat): boolean {
-    // are two planes the same?
-    const a = this.normalize();
-    const b = p.normalize();
-    return a.dist(b) < eps || a.dist(b.smul(-1)) < eps;
-  }
-
-  public makecut(r: number): Quat {
-    // make a cut from a normal vector
-    return new Quat(r, this.b, this.c, this.d);
-  }
-}

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

@@ -1,144 +0,0 @@
-import { identity, Perm } from "./Perm";
-
-class FactoredNumber {
-  public mult: number[];
-  constructor() {
-    this.mult = [];
-  }
-
-  public multiply(n: number): void {
-    for (let f = 2; f * f <= n; f++) {
-      while (n % f === 0) {
-        if (undefined !== this.mult[f]) {
-          this.mult[f]++;
-        } else {
-          this.mult[f] = 1;
-        }
-        n /= f;
-      }
-    }
-    if (n > 1) {
-      if (undefined !== this.mult[n]) {
-        this.mult[n]++;
-      } else {
-        this.mult[n] = 1;
-      }
-    }
-  }
-
-  public toString(): string {
-    let r = "";
-    for (let i = 0; i < this.mult.length; i++) {
-      if (undefined !== this.mult[i]) {
-        if (r !== "") {
-          r += "*";
-        }
-        r += i;
-        if (this.mult[i] > 1) {
-          r += `^${this.mult[i]}`;
-        }
-      }
-    }
-    return r;
-  }
-}
-
-export function schreierSims(g: Perm[], disp: (s: string) => void): number {
-  const n = g[0].p.length;
-  const e = identity(n);
-  let sgs: Perm[][] = [];
-  let sgsi: Perm[][] = [];
-  let sgslen: number[][] = [];
-  let Tk: Perm[][] = [];
-  let Tklen: number[][] = [];
-  function resolve(p: Perm): boolean {
-    for (let i = p.p.length - 1; i >= 0; i--) {
-      const j = p.p[i];
-      if (j !== i) {
-        if (!sgs[i][j]) {
-          return false;
-        }
-        p = p.mul(sgsi[i][j]);
-      }
-    }
-    return true;
-  }
-  function knutha(k: number, p: Perm, len: number): void {
-    Tk[k].push(p);
-    Tklen[k].push(len);
-    for (let i = 0; i < sgs[k].length; i++) {
-      if (sgs[k][i]) {
-        knuthb(k, sgs[k][i].mul(p), len + sgslen[k][i]);
-      }
-    }
-  }
-  function knuthb(k: number, p: Perm, len: number): void {
-    const j = p.p[k];
-    if (!sgs[k][j]) {
-      sgs[k][j] = p;
-      sgsi[k][j] = p.inv();
-      sgslen[k][j] = len;
-      for (let i = 0; i < Tk[k].length; i++) {
-        knuthb(k, p.mul(Tk[k][i]), len + Tklen[k][i]);
-      }
-      return;
-    }
-    const p2 = p.mul(sgsi[k][j]);
-    if (!resolve(p2)) {
-      knutha(k - 1, p2, len + sgslen[k][j]);
-    }
-  }
-  function getsgs(): number {
-    sgs = [];
-    sgsi = [];
-    Tk = [];
-    sgslen = [];
-    Tklen = [];
-    for (let i = 0; i < n; i++) {
-      sgs.push([]);
-      sgsi.push([]);
-      sgslen.push([]);
-      Tk.push([]);
-      Tklen.push([]);
-      sgs[i][i] = e;
-      sgsi[i][i] = e;
-      sgslen[i][i] = 0;
-    }
-    let none = 0;
-    let sz = 1;
-    for (let i = 0; i < g.length; i++) {
-      knutha(n - 1, g[i], 1);
-      sz = 1;
-      let tks = 0;
-      let sollen = 0;
-      const avgs = [];
-      const mults = new FactoredNumber();
-      for (let j = 0; j < n; j++) {
-        let cnt = 0;
-        let lensum = 0;
-        for (let k = 0; k < n; k++) {
-          if (sgs[j][k]) {
-            cnt++;
-            lensum += sgslen[j][k];
-            if (j !== k) {
-              none++;
-            }
-          }
-        }
-        tks += Tk[j].length;
-        sz *= cnt;
-        if (cnt > 1) {
-          mults.multiply(cnt);
-        }
-        const avg = lensum / cnt;
-        avgs.push(avg);
-        sollen += avg;
-      }
-      disp(
-        `${i}: sz ${sz} T ${tks} sol ${sollen} none ${none} mults ${mults.toString()}`,
-      );
-    }
-    return sz;
-  }
-  return getsgs();
-}

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

@@ -1,17 +0,0 @@
-export {
-  getpuzzle,
-  getPuzzleGeometryByDesc,
-  getPuzzleGeometryByName,
-  getpuzzles,
-  parsePuzzleDescription,
-  PuzzleGeometry,
-} from "./PuzzleGeometry";
-export type {
-  StickerDat,
-  StickerDatAxis,
-  StickerDatFace,
-  StickerDatSticker,
-} from "./PuzzleGeometry";
-export { parseOptions } from "./Options";
-export { Quat } from "./Quat";
-export { schreierSims } from "./SchreierSims";

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

@@ -1,6 +0,0 @@
-import type { Move } from "../alg";
-import type { Transformation } from "../kpuzzle";
-
-export interface MoveNotation {
-  lookupMove(move: Move): Transformation | undefined;
-}

package/src/cubing/puzzle-geometry/notation-mapping/FTONotationMapper.ts

@@ -1,38 +0,0 @@
-import { Move, QuantumMove } from "../../alg";
-import type { FaceNameSwizzler } from "../FaceNameSwizzler";
-import type { NotationMapper } from "./NotationMapper";
-
-export class FTONotationMapper implements NotationMapper {
-  constructor(private child: NotationMapper, private sw: FaceNameSwizzler) {}
-
-  public notationToInternal(move: Move): Move | null {
-    if (
-      move.family === "T" &&
-      move.innerLayer === undefined &&
-      move.outerLayer === undefined
-    ) {
-      return new Move(
-        new QuantumMove("FLRv", move.innerLayer, move.outerLayer),
-        move.amount,
-      );
-    } else {
-      const r = this.child.notationToInternal(move);
-      return r;
-    }
-  }
-
-  // we never rewrite click moves to these moves.
-  public notationToExternal(move: Move): Move | null {
-    let fam = move.family;
-    if (fam.length > 0 && fam[fam.length - 1] === "v") {
-      fam = fam.substring(0, fam.length - 1);
-    }
-    if (this.sw.spinmatch(fam, "FLUR")) {
-      return new Move(
-        new QuantumMove("T", move.innerLayer, move.outerLayer),
-        move.amount,
-      );
-    }
-    return this.child.notationToExternal(move);
-  }
-}

package/src/cubing/puzzle-geometry/notation-mapping/FaceRenamingMapper.ts

@@ -1,59 +0,0 @@
-// face renaming mapper.  Accepts two face name remappers.  We
-// work between the two.
-
-import { Move, QuantumMove } from "../../alg";
-import type { FaceNameSwizzler } from "../FaceNameSwizzler";
-import type { NotationMapper } from "./NotationMapper";
-
-export class FaceRenamingMapper implements NotationMapper {
-  constructor(
-    public internalNames: FaceNameSwizzler,
-    public externalNames: FaceNameSwizzler,
-  ) {}
-
-  // TODO:  consider putting a cache in front of this
-  public convertString(
-    grip: string,
-    a: FaceNameSwizzler,
-    b: FaceNameSwizzler,
-  ): string {
-    let suffix = "";
-    if ((grip.endsWith("v") || grip.endsWith("v")) && grip <= "_") {
-      suffix = grip.slice(grip.length - 1);
-      grip = grip.slice(0, grip.length - 1);
-    }
-    const upper = grip.toUpperCase();
-    let isLowerCase = false;
-    if (grip !== upper) {
-      isLowerCase = true;
-      grip = upper;
-    }
-    grip = b.joinByFaceIndices(a.splitByFaceNames(grip));
-    if (isLowerCase) {
-      grip = grip.toLowerCase();
-    }
-    return grip + suffix;
-  }
-
-  public convert(move: Move, a: FaceNameSwizzler, b: FaceNameSwizzler): Move {
-    const grip = move.family;
-    const ngrip = this.convertString(grip, a, b);
-    if (grip === ngrip) {
-      return move;
-    } else {
-      return new Move(
-        new QuantumMove(ngrip, move.innerLayer, move.outerLayer),
-        move.amount,
-      );
-    }
-  }
-
-  public notationToInternal(move: Move): Move {
-    const r = this.convert(move, this.externalNames, this.internalNames);
-    return r;
-  }
-
-  public notationToExternal(move: Move): Move {
-    return this.convert(move, this.internalNames, this.externalNames);
-  }
-}

package/src/cubing/puzzle-geometry/notation-mapping/MegaminxScramblingNotationMapper.ts

@@ -1,50 +0,0 @@
-// Sits on top of a (possibly null) notation mapper, and
-
-import { Move, QuantumMove } from "../../alg";
-import type { NotationMapper } from "./NotationMapper";
-
-// adds R++/R--/D++/D-- notation mapping.
-export class MegaminxScramblingNotationMapper implements NotationMapper {
-  constructor(private child: NotationMapper) {}
-
-  public notationToInternal(move: Move): Move | null {
-    if (move.innerLayer === undefined && move.outerLayer === undefined) {
-      if (Math.abs(move.amount) === 1) {
-        if (move.family === "R++") {
-          return new Move(new QuantumMove("L", 3, 2), -2 * move.amount);
-        } else if (move.family === "R--") {
-          return new Move(new QuantumMove("L", 3, 2), 2 * move.amount);
-        } else if (move.family === "D++") {
-          return new Move(new QuantumMove("U", 3, 2), -2 * move.amount);
-        } else if (move.family === "D--") {
-          return new Move(new QuantumMove("U", 3, 2), 2 * move.amount);
-        }
-
-        // TODO: Figure out if `cubing/alg` should parse `R++` to a family of `R++`.
-        if (move.family === "R_PLUSPLUS_") {
-          return new Move(new QuantumMove("L", 3, 2), -2 * move.amount);
-        } else if (move.family === "D_PLUSPLUS_") {
-          return new Move(new QuantumMove("U", 3, 2), -2 * move.amount);
-        }
-      }
-      if (move.family === "y") {
-        return new Move("Uv", move.amount);
-      }
-    }
-    return this.child.notationToInternal(move);
-  }
-
-  // we never rewrite click moves to these moves.
-  public notationToExternal(move: Move): Move | null {
-    if (move.family === "Uv") {
-      return new Move(
-        new QuantumMove("y", move.innerLayer, move.outerLayer),
-        move.amount,
-      );
-    }
-    if (move.family === "Dv") {
-      return new Move("y", -move.amount);
-    }
-    return this.child.notationToExternal(move);
-  }
-}

package/src/cubing/puzzle-geometry/notation-mapping/NotationMapper.ts

@@ -1,6 +0,0 @@
-import type { Move } from "../../alg";
-
-export interface NotationMapper {
-  notationToInternal(move: Move): Move | null;
-  notationToExternal(move: Move): Move | null;
-}

package/src/cubing/puzzle-geometry/notation-mapping/NullMapper.ts

@@ -1,12 +0,0 @@
-import type { Move } from "../../alg";
-import type { NotationMapper } from "./NotationMapper";
-
-export class NullMapper implements NotationMapper {
-  public notationToInternal(move: Move): Move | null {
-    return move;
-  }
-
-  public notationToExternal(move: Move): Move | null {
-    return move;
-  }
-}