cubing 0.23.0 → 0.24.0-pre1

package/src/cubing/kpuzzle/3x3x3/3x3x3.kpuzzle.json.ts

@@ -1,339 +0,0 @@
-// TODO: This file is here to avoid dependency loops, but it should eventually
-// move back into `cubing/puzzles`. We currently have a few functions that are
-// hardcoded to require synchronous access to this definition, and we need to
-// find a better way to do that.
-
-// TODO: this would be a raw `.json` file, but Parcel runs into an error from
-
-import type { KPuzzleDefinition } from "..";
-
-// using that as both a sync and async import. Probably https://github.com/parcel-bundler/parcel/issues/2546
-export const cube3x3x3KPuzzle: KPuzzleDefinition = {
-  name: "3x3x3",
-  orbits: {
-    EDGES: { numPieces: 12, orientations: 2 },
-    CORNERS: { numPieces: 8, orientations: 3 },
-    CENTERS: { numPieces: 6, orientations: 4 },
-  },
-  startPieces: {
-    EDGES: {
-      permutation: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
-      orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-    },
-    CORNERS: {
-      permutation: [0, 1, 2, 3, 4, 5, 6, 7],
-      orientation: [0, 0, 0, 0, 0, 0, 0, 0],
-    },
-    CENTERS: {
-      permutation: [0, 1, 2, 3, 4, 5],
-      orientation: [0, 0, 0, 0, 0, 0],
-    },
-  },
-  moves: {
-    U: {
-      EDGES: {
-        permutation: [1, 2, 3, 0, 4, 5, 6, 7, 8, 9, 10, 11],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      },
-      CORNERS: {
-        permutation: [1, 2, 3, 0, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0],
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [1, 0, 0, 0, 0, 0],
-      },
-    },
-    y: {
-      EDGES: {
-        permutation: [1, 2, 3, 0, 5, 6, 7, 4, 10, 8, 11, 9],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
-      },
-      CORNERS: {
-        permutation: [1, 2, 3, 0, 7, 4, 5, 6],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0],
-      },
-      CENTERS: {
-        permutation: [0, 2, 3, 4, 1, 5],
-        orientation: [1, 0, 0, 0, 0, 3],
-      },
-    },
-    x: {
-      EDGES: {
-        permutation: [4, 8, 0, 9, 6, 10, 2, 11, 5, 7, 1, 3],
-        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0],
-      },
-      CORNERS: {
-        permutation: [4, 0, 3, 5, 7, 6, 2, 1],
-        orientation: [2, 1, 2, 1, 1, 2, 1, 2],
-      },
-      CENTERS: {
-        permutation: [2, 1, 5, 3, 0, 4],
-        orientation: [0, 3, 0, 1, 2, 2],
-      },
-    },
-    L: {
-      EDGES: {
-        permutation: [0, 1, 2, 11, 4, 5, 6, 9, 8, 3, 10, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      },
-      CORNERS: {
-        permutation: [0, 1, 6, 2, 4, 3, 5, 7],
-        orientation: [0, 0, 2, 1, 0, 2, 1, 0],
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 1, 0, 0, 0, 0],
-      },
-    },
-    F: {
-      EDGES: {
-        permutation: [9, 1, 2, 3, 8, 5, 6, 7, 0, 4, 10, 11],
-        orientation: [1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0],
-      },
-      CORNERS: {
-        permutation: [3, 1, 2, 5, 0, 4, 6, 7],
-        orientation: [1, 0, 0, 2, 2, 1, 0, 0],
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 1, 0, 0, 0],
-      },
-    },
-    R: {
-      EDGES: {
-        permutation: [0, 8, 2, 3, 4, 10, 6, 7, 5, 9, 1, 11],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      },
-      CORNERS: {
-        permutation: [4, 0, 2, 3, 7, 5, 6, 1],
-        orientation: [2, 1, 0, 0, 1, 0, 0, 2],
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 0, 1, 0, 0],
-      },
-    },
-    B: {
-      EDGES: {
-        permutation: [0, 1, 10, 3, 4, 5, 11, 7, 8, 9, 6, 2],
-        orientation: [0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1],
-      },
-      CORNERS: {
-        permutation: [0, 7, 1, 3, 4, 5, 2, 6],
-        orientation: [0, 2, 1, 0, 0, 0, 2, 1],
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 0, 0, 1, 0],
-      },
-    },
-    D: {
-      EDGES: {
-        permutation: [0, 1, 2, 3, 7, 4, 5, 6, 8, 9, 10, 11],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 5, 6, 7, 4],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0],
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 0, 0, 0, 1],
-      },
-    },
-    z: {
-      EDGES: {
-        permutation: [9, 3, 11, 7, 8, 1, 10, 5, 0, 4, 2, 6],
-        orientation: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
-      },
-      CORNERS: {
-        permutation: [3, 2, 6, 5, 0, 4, 7, 1],
-        orientation: [1, 2, 1, 2, 2, 1, 2, 1],
-      },
-      CENTERS: {
-        permutation: [1, 5, 2, 0, 4, 3],
-        orientation: [1, 1, 1, 1, 3, 1],
-      },
-    },
-    M: {
-      EDGES: {
-        permutation: [2, 1, 6, 3, 0, 5, 4, 7, 8, 9, 10, 11],
-        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0],
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0],
-      },
-      CENTERS: {
-        permutation: [4, 1, 0, 3, 5, 2],
-        orientation: [2, 0, 0, 0, 2, 0],
-      },
-    },
-    E: {
-      EDGES: {
-        permutation: [0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 8, 10],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0],
-      },
-      CENTERS: {
-        permutation: [0, 4, 1, 2, 3, 5],
-        orientation: [0, 0, 0, 0, 0, 0],
-      },
-    },
-    S: {
-      EDGES: {
-        permutation: [0, 3, 2, 7, 4, 1, 6, 5, 8, 9, 10, 11],
-        orientation: [0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0],
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0],
-      },
-      CENTERS: {
-        permutation: [1, 5, 2, 0, 4, 3],
-        orientation: [1, 1, 0, 1, 0, 1],
-      },
-    },
-    u: {
-      EDGES: {
-        permutation: [1, 2, 3, 0, 4, 5, 6, 7, 10, 8, 11, 9],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
-      },
-      CORNERS: {
-        permutation: [1, 2, 3, 0, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0],
-      },
-      CENTERS: {
-        permutation: [0, 2, 3, 4, 1, 5],
-        orientation: [1, 0, 0, 0, 0, 0],
-      },
-    },
-    l: {
-      EDGES: {
-        permutation: [2, 1, 6, 11, 0, 5, 4, 9, 8, 3, 10, 7],
-        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0],
-      },
-      CORNERS: {
-        permutation: [0, 1, 6, 2, 4, 3, 5, 7],
-        orientation: [0, 0, 2, 1, 0, 2, 1, 0],
-      },
-      CENTERS: {
-        permutation: [4, 1, 0, 3, 5, 2],
-        orientation: [2, 1, 0, 0, 2, 0],
-      },
-    },
-    f: {
-      EDGES: {
-        permutation: [9, 3, 2, 7, 8, 1, 6, 5, 0, 4, 10, 11],
-        orientation: [1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0],
-      },
-      CORNERS: {
-        permutation: [3, 1, 2, 5, 0, 4, 6, 7],
-        orientation: [1, 0, 0, 2, 2, 1, 0, 0],
-      },
-      CENTERS: {
-        permutation: [1, 5, 2, 0, 4, 3],
-        orientation: [1, 1, 1, 1, 0, 1],
-      },
-    },
-    r: {
-      EDGES: {
-        permutation: [4, 8, 0, 3, 6, 10, 2, 7, 5, 9, 1, 11],
-        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0],
-      },
-      CORNERS: {
-        permutation: [4, 0, 2, 3, 7, 5, 6, 1],
-        orientation: [2, 1, 0, 0, 1, 0, 0, 2],
-      },
-      CENTERS: {
-        permutation: [2, 1, 5, 3, 0, 4],
-        orientation: [0, 0, 0, 1, 2, 2],
-      },
-    },
-    b: {
-      EDGES: {
-        permutation: [0, 5, 10, 1, 4, 7, 11, 3, 8, 9, 6, 2],
-        orientation: [0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1],
-      },
-      CORNERS: {
-        permutation: [0, 7, 1, 3, 4, 5, 2, 6],
-        orientation: [0, 2, 1, 0, 0, 0, 2, 1],
-      },
-      CENTERS: {
-        permutation: [3, 0, 2, 5, 4, 1],
-        orientation: [3, 3, 0, 3, 1, 3],
-      },
-    },
-    d: {
-      EDGES: {
-        permutation: [0, 1, 2, 3, 7, 4, 5, 6, 9, 11, 8, 10],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 5, 6, 7, 4],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0],
-      },
-      CENTERS: {
-        permutation: [0, 4, 1, 2, 3, 5],
-        orientation: [0, 0, 0, 0, 0, 1],
-      },
-    },
-  },
-};
-
-cube3x3x3KPuzzle.moves["Uw"] = cube3x3x3KPuzzle.moves["u"];
-cube3x3x3KPuzzle.moves["Lw"] = cube3x3x3KPuzzle.moves["l"];
-cube3x3x3KPuzzle.moves["Fw"] = cube3x3x3KPuzzle.moves["f"];
-cube3x3x3KPuzzle.moves["Rw"] = cube3x3x3KPuzzle.moves["r"];
-cube3x3x3KPuzzle.moves["Bw"] = cube3x3x3KPuzzle.moves["b"];
-cube3x3x3KPuzzle.moves["Dw"] = cube3x3x3KPuzzle.moves["d"];
-
-cube3x3x3KPuzzle.moves["Rv"] = cube3x3x3KPuzzle.moves["x"];
-cube3x3x3KPuzzle.moves["Uv"] = cube3x3x3KPuzzle.moves["y"];
-cube3x3x3KPuzzle.moves["Fv"] = cube3x3x3KPuzzle.moves["z"];
-cube3x3x3KPuzzle.moves["Lv"] = {
-  EDGES: {
-    permutation: [2, 10, 6, 11, 0, 8, 4, 9, 1, 3, 5, 7],
-    orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0],
-  },
-  CORNERS: {
-    permutation: [1, 7, 6, 2, 0, 3, 5, 4],
-    orientation: [2, 1, 2, 1, 1, 2, 1, 2],
-  },
-  CENTERS: {
-    permutation: [4, 1, 0, 3, 5, 2],
-    orientation: [2, 1, 0, 3, 2, 0],
-  },
-};
-cube3x3x3KPuzzle.moves["Dv"] = {
-  EDGES: {
-    permutation: [3, 0, 1, 2, 7, 4, 5, 6, 9, 11, 8, 10],
-    orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
-  },
-  CORNERS: {
-    permutation: [3, 0, 1, 2, 5, 6, 7, 4],
-    orientation: [0, 0, 0, 0, 0, 0, 0, 0],
-  },
-  CENTERS: {
-    permutation: [0, 4, 1, 2, 3, 5],
-    orientation: [3, 0, 0, 0, 0, 1],
-  },
-};
-cube3x3x3KPuzzle.moves["Bv"] = {
-  EDGES: {
-    permutation: [8, 5, 10, 1, 9, 7, 11, 3, 4, 0, 6, 2],
-    orientation: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
-  },
-  CORNERS: {
-    permutation: [4, 7, 1, 0, 5, 3, 2, 6],
-    orientation: [1, 2, 1, 2, 2, 1, 2, 1],
-  },
-  CENTERS: {
-    permutation: [3, 0, 2, 5, 4, 1],
-    orientation: [3, 3, 3, 3, 1, 3],
-  },
-};

package/src/cubing/kpuzzle/canon.spec.ts

@@ -1,48 +0,0 @@
-import { getPuzzleGeometryByName } from "../puzzle-geometry";
-import { areStatesEquivalent, combineTransformations } from ".";
-import { Canonicalizer, CanonicalSequenceIterator } from "./canonicalize";
-import { Alg } from "../alg";
-
-describe("CanonSequences", () => {
-  it("should merge sequences (megaminx test)", () => {
-    const pg = getPuzzleGeometryByName("megaminx", {});
-    const def = pg.writekpuzzle(false);
-    const canon = new Canonicalizer(def);
-    const a1 = "U F2 BL R3 L3";
-    const a2 = "L2 BL2 F' U2";
-    const ss1 = canon.sequenceToSearchSequence(Alg.fromString(a1));
-    expect(ss1.moveseq.length).toBe(5);
-    const ss2 = canon.sequenceToSearchSequence(Alg.fromString(a2));
-    expect(ss2.moveseq.length).toBe(4);
-    const ss3 = canon.mergeSequenceToSearchSequence(
-      Alg.fromString(a1 + " " + a2),
-    );
-    expect(ss3.moveseq.length).toBe(6);
-    expect(ss3.getSequenceAsString()).toBe("U F2 BL2' R2' F' U2");
-    expect(
-      areStatesEquivalent(
-        def,
-        ss3.trans,
-        combineTransformations(def, ss1.trans, ss2.trans),
-      ),
-    ).toBeTruthy();
-  });
-  it("should generate canonical sequences (3x3x3 test)", () => {
-    const pg = getPuzzleGeometryByName("3x3x3", { allMoves: false });
-    const def = pg.writekpuzzle(false);
-    const canon = new Canonicalizer(def);
-    const cnts = [0, 0, 0, 0];
-    const csi = new CanonicalSequenceIterator(canon);
-    const gen = csi.generator();
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const seq = gen.next();
-      const len = seq.value.moveseq.length;
-      if (len > 3) {
-        break;
-      }
-      cnts[len]++;
-    }
-    expect(cnts).toStrictEqual([1, 18, 243, 3240]);
-  });
-});

package/src/cubing/kpuzzle/canonicalize.ts

@@ -1,325 +0,0 @@
-/**
- *  This module manages canonical sequences.  You can merge sequences
- *  combining moves (fully respecting commuting moves), and you can
- *  generate canonical sequences efficiently.
- */
-import type { Alg, Move } from "../alg";
-import type { KPuzzleDefinition, Transformation } from "./definition_types";
-import {
-  areTransformationsEquivalent,
-  combineTransformations,
-  identityTransformation,
-} from "./transformations";
-
-class InternalMove {
-  constructor(public base: number, public twist: number) {}
-  public getTransformation(canon: Canonicalizer): Transformation {
-    return canon.transforms[this.base][this.twist];
-  }
-
-  public asString(canon: Canonicalizer): string {
-    const mod = canon.moveorder[this.base];
-    let tw = this.twist % mod;
-    while (tw + tw > mod) {
-      tw -= mod;
-    }
-    while (tw + tw <= -mod) {
-      tw += mod;
-    }
-    const nam = canon.movenames[this.base];
-    if (tw === 1) {
-      return nam;
-    } else if (tw === -1) {
-      return nam + "'";
-    } else if (tw > 0) {
-      return nam + tw;
-    } else if (tw < 0) {
-      return nam + -tw + "'";
-    } else {
-      throw new Error("Stringifying null move?");
-    }
-  }
-}
-
-// represents puzzle move data and its commuting structure
-export class Canonicalizer {
-  public commutes: boolean[][] = [];
-  public moveorder: number[] = [];
-  public movenames: string[] = [];
-  public transforms: Transformation[][] = [];
-  public moveindex: { [key: string]: number } = {};
-  public baseMoveCount: number;
-  constructor(public def: KPuzzleDefinition) {
-    const basemoves = def.moves;
-    const id = identityTransformation(def);
-    for (const mv1 in basemoves) {
-      this.moveindex[mv1] = this.movenames.length;
-      this.movenames.push(mv1);
-      this.transforms.push([id, basemoves[mv1]]);
-    }
-    this.baseMoveCount = this.movenames.length;
-    for (let i = 0; i < this.baseMoveCount; i++) {
-      this.commutes.push([]);
-      const t1 = this.transforms[i][1];
-      for (let j = 0; j < this.baseMoveCount; j++) {
-        const t2 = this.transforms[j][1];
-        const ab = combineTransformations(def, t1, t2);
-        const ba = combineTransformations(def, t2, t1);
-        this.commutes[i][j] = areTransformationsEquivalent(def, ab, ba);
-      }
-    }
-    for (let i = 0; i < this.baseMoveCount; i++) {
-      const t1 = this.transforms[i][1];
-      let ct = t1;
-      let order = 1;
-      for (let mult = 2; !areTransformationsEquivalent(def, id, ct); mult++) {
-        order++;
-        ct = combineTransformations(def, ct, t1);
-        this.transforms[i].push(ct);
-      }
-      this.moveorder[i] = order;
-    }
-  }
-
-  public blockMoveToInternalMove(move: Move): InternalMove {
-    const quantumMoveStr = move.quantum.toString();
-    if (!(quantumMoveStr in this.def.moves)) {
-      throw new Error("! move " + quantumMoveStr + " not in def.");
-    }
-    const ind = this.moveindex[quantumMoveStr];
-    const mod = this.moveorder[ind];
-    let tw = move.amount % mod; // TODO
-    if (tw < 0) {
-      tw = (tw + mod) % mod;
-    }
-    return new InternalMove(ind, tw);
-  }
-
-  // Sequence must be simple sequence of block moves
-  // this one does not attempt to merge.
-  public sequenceToSearchSequence(
-    alg: Alg,
-    tr?: Transformation,
-  ): SearchSequence {
-    const ss = new SearchSequence(this, tr);
-    for (const move of alg.experimentalLeafMoves()) {
-      ss.appendOneMove(this.blockMoveToInternalMove(move));
-    }
-    return ss;
-  }
-
-  // Sequence to simple sequence, with merging.
-  public mergeSequenceToSearchSequence(
-    alg: Alg,
-    tr?: Transformation,
-  ): SearchSequence {
-    const ss = new SearchSequence(this, tr);
-    for (const move of alg.experimentalLeafMoves()) {
-      ss.mergeOneMove(this.blockMoveToInternalMove(move));
-    }
-    return ss;
-  }
-}
-
-// represents a single sequence we are working on
-// this can be a search sequence, or it can be a
-// "cooked" sequence that we want to use efficiently.
-export class SearchSequence {
-  public moveseq: InternalMove[] = [];
-  public trans: Transformation;
-  constructor(private canon: Canonicalizer, tr?: Transformation) {
-    if (tr) {
-      this.trans = tr;
-    } else {
-      this.trans = identityTransformation(canon.def);
-    }
-  }
-
-  /*
-   *  A common use for search sequences is to extend them, but
-   *  sometimes we shouldn't modify the returned one.  This
-   *  method gives you a copy you can do whatever you want with.
-   */
-  public clone(): SearchSequence {
-    const r = new SearchSequence(this.canon, this.trans);
-    r.moveseq = [...this.moveseq];
-    return r;
-  }
-
-  // returns 1 if the move is added, 0 if it is merged, -1 if it cancels a move
-  public mergeOneMove(mv: InternalMove): number {
-    const r = this.onlyMergeOneMove(mv);
-    this.trans = combineTransformations(
-      this.canon.def,
-      this.trans,
-      mv.getTransformation(this.canon),
-    );
-    return r;
-  }
-
-  // does not do merge work; just slaps the new move on
-  public appendOneMove(mv: InternalMove): number {
-    this.moveseq.push(mv);
-    this.trans = combineTransformations(
-      this.canon.def,
-      this.trans,
-      mv.getTransformation(this.canon),
-    );
-    return 1;
-  }
-
-  // pop a move off.
-  public popMove(): number {
-    const mv = this.moveseq.pop();
-    if (!mv) {
-      throw new Error("Can't pop an empty sequence");
-    }
-    this.trans = combineTransformations(
-      this.canon.def,
-      this.trans,
-      this.canon.transforms[mv.base][this.canon.moveorder[mv.base] - mv.twist],
-    );
-    return 1;
-  }
-
-  // do one more twist of the last move
-  public oneMoreTwist(): number {
-    const lastmv = this.moveseq[this.moveseq.length - 1];
-    this.trans = combineTransformations(
-      this.canon.def,
-      this.trans,
-      this.canon.transforms[lastmv.base][1],
-    );
-    this.moveseq[this.moveseq.length - 1] = new InternalMove(
-      lastmv.base,
-      lastmv.twist + 1,
-    );
-    return 0;
-  }
-
-  private onlyMergeOneMove(mv: InternalMove): number {
-    let j = this.moveseq.length - 1;
-    while (j >= 0) {
-      if (mv.base === this.moveseq[j].base) {
-        const mo = this.canon.moveorder[mv.base];
-        let twist = (mv.twist + this.moveseq[j].twist) % mo;
-        if (twist < 0) {
-          twist = (twist + mo) % mo;
-        }
-        if (twist === 0) {
-          // this splice should not be a performance problem because the
-          // typical number of following moves should be small
-          this.moveseq.splice(j, 1);
-          return -1;
-        } else {
-          this.moveseq[j] = new InternalMove(mv.base, twist);
-          return 0;
-        }
-      } else if (this.canon.commutes[mv.base][this.moveseq[j].base]) {
-        j--;
-      } else {
-        break;
-      }
-    }
-    this.moveseq.push(mv);
-    return 1;
-  }
-
-  // returns the length of the merged sequence.
-  public mergeSequence(seq: SearchSequence): number {
-    let r = this.moveseq.length;
-    for (let i = 0; i < seq.moveseq.length; i++) {
-      const mv = seq.moveseq[i];
-      const d = this.onlyMergeOneMove(mv);
-      r += d;
-    }
-    this.trans = combineTransformations(this.canon.def, this.trans, seq.trans);
-    return r;
-  }
-
-  public getSequenceAsString(): string {
-    const r: string[] = [];
-    for (const mv of this.moveseq) {
-      r.push(mv.asString(this.canon));
-    }
-    return r.join(" ");
-  }
-}
-
-/*
- *   Iterate through canonical sequences by length.  This version
- *   uses generators.
- */
-export class CanonicalSequenceIterator {
-  public ss: SearchSequence;
-  public targetLength: number;
-  constructor(public canon: Canonicalizer, state?: Transformation) {
-    this.ss = new SearchSequence(canon, state);
-    this.targetLength = 0;
-  }
-
-  public nextState(base: number, canonstate: number[]): null | number[] {
-    const newstate: number[] = [];
-    for (const prevbase of canonstate) {
-      if (prevbase === base) {
-        return null;
-      } else if (!this.canon.commutes[prevbase][base]) {
-        // don't do anything in this case
-      } else if (base < prevbase) {
-        return null;
-      } else {
-        newstate.push(prevbase);
-      }
-    }
-    return newstate;
-  }
-
-  public *genSequence(
-    togo: number,
-    canonstate: number[],
-  ): Generator<SearchSequence, null, void> {
-    if (togo === 0) {
-      yield this.ss;
-    } else {
-      for (let base = 0; base < this.canon.baseMoveCount; base++) {
-        const newstate = this.nextState(base, canonstate);
-        if (newstate) {
-          newstate.push(base);
-          for (let tw = 1; tw < this.canon.moveorder[base]; tw++) {
-            this.ss.appendOneMove(new InternalMove(base, tw));
-            yield* this.genSequence(togo - 1, newstate);
-            this.ss.popMove();
-          }
-        }
-      }
-    }
-    return null;
-  }
-
-  public *generator(): Generator<SearchSequence, SearchSequence, void> {
-    for (let d = 0; ; d++) {
-      yield* this.genSequence(d, []);
-    }
-  }
-
-  public *genSequenceTree(
-    canonstate: number[],
-  ): Generator<SearchSequence, null, number> {
-    const r = yield this.ss;
-    if (r > 0) {
-      return null;
-    }
-    for (let base = 0; base < this.canon.baseMoveCount; base++) {
-      const newstate = this.nextState(base, canonstate);
-      if (newstate) {
-        newstate.push(base);
-        for (let tw = 1; tw < this.canon.moveorder[base]; tw++) {
-          this.ss.appendOneMove(new InternalMove(base, tw));
-          yield* this.genSequenceTree(newstate);
-          this.ss.popMove();
-        }
-      }
-    }
-    return null;
-  }
-}