cubing 0.22.0 → 0.24.0-pre2

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

@@ -1,179 +0,0 @@
-import { parsePuzzleDescription, PuzzleDescription } from "./PuzzleGeometry";
-
-export function parseOptions(argv: string[]): {
-  puzzleDescription: PuzzleDescription | null;
-  options: PuzzleGeometryOptions;
-} {
-  let argp = 0;
-  const options: PuzzleGeometryOptions = {};
-  while (argp < argv.length && argv[argp][0] === "-") {
-    const option = argv[argp++];
-    if (option === "--rotations") {
-      options.addRotations = true;
-    } else if (option === "--allmoves") {
-      options.allMoves = true;
-    } else if (option === "--outerblockmoves") {
-      options.outerBlockMoves = true;
-    } else if (option === "--vertexmoves") {
-      options.vertexMoves = true;
-    } else if (option === "--nocorners") {
-      options.includeCornerOrbits = false;
-    } else if (option === "--noedges") {
-      options.includeEdgeOrbits = false;
-    } else if (option === "--noorientation") {
-      options.fixedOrientation = true;
-    } else if (option === "--nocenters") {
-      options.includeCenterOrbits = false;
-    } else if (option === "--omit") {
-      options.excludeOrbits = argv[argp].split(",");
-      argp++;
-    } else if (option === "--moves") {
-      options.moveList = argv[argp].split(",");
-      argp++;
-    } else if (option === "--optimize") {
-      options.optimizeOrbits = true;
-    } else if (option === "--scramble") {
-      options.scrambleAmount = 100;
-    } else if (option === "--fixcorner") {
-      options.fixedPieceType = "v";
-    } else if (option === "--fixedge") {
-      options.fixedPieceType = "e";
-    } else if (option === "--fixcenter") {
-      options.fixedPieceType = "f";
-    } else if (option === "--orientcenters") {
-      options.orientCenters = true;
-    } else if (option === "--puzzleorientation") {
-      options.puzzleOrientation = JSON.parse(argv[argp]); // TODO: Validate input.
-      argp++;
-    } else {
-      throw new Error("Bad option: " + option);
-    }
-  }
-  const puzzleDescription = parsePuzzleDescription(argv.slice(argp).join(" "));
-  return { puzzleDescription, options };
-}
-
-type FaceName = string;
-type OrientationDirection = [number, number, number];
-export type FaceBasedOrientationDescription = [
-  [FaceName, OrientationDirection],
-  [FaceName, OrientationDirection],
-];
-export type BaseFaceCount = 4 | 6 | 8 | 12 | 20;
-export type FaceBasedOrientationDescriptionLookup = Record<
-  BaseFaceCount,
-  FaceBasedOrientationDescription
->;
-
-function asstructured(v: any): any {
-  if (typeof v === "string") {
-    return JSON.parse(v);
-  }
-  return v;
-}
-function asboolean(v: any): boolean {
-  if (typeof v === "string") {
-    if (v === "false") {
-      return false;
-    }
-    return true;
-  } else {
-    return v ? true : false;
-  }
-}
-
-export class PuzzleGeometryFullOptions {
-  verbosity: number = 0; // verbosity (console.log)
-
-  allMoves: boolean = false; // generate all slice moves in ksolve
-  outerBlockMoves: boolean; // generate outer block moves
-  vertexMoves: boolean = false; // generate vertex moves
-  addRotations: boolean = false; // add symmetry information to ksolve output
-  moveList: string[] | null = null; // move list to generate
-
-  fixedOrientation: boolean = false; // eliminate any orientations
-  fixedPieceType: null | "e" | "v" | "f" = null; // fix a piece?
-  orientCenters: boolean = false; // orient centers?
-
-  // TODO: Group these into a single object?
-  includeCornerOrbits: boolean = true; // include corner orbits
-  includeCenterOrbits: boolean = true; // include center orbits
-  includeEdgeOrbits: boolean = true; // include edge orbits
-  // Overrides the previous options.
-  excludeOrbits: string[] = []; // exclude these orbits
-  optimizeOrbits: boolean = false; // optimize PermOri
-
-  grayCorners: boolean = false; // make corner sets gray
-  grayCenters: boolean = false; // make center sets gray
-  grayEdges: boolean = false; // make edge sets gray
-
-  puzzleOrientation: FaceBasedOrientationDescription | null = null; // single puzzle orientation from options
-  puzzleOrientations: FaceBasedOrientationDescriptionLookup | null = null; // puzzle orientation override object from options // TODO: is this needed?
-
-  scrambleAmount: number = 0; // scramble?
-
-  constructor(options: PuzzleGeometryOptions = {}) {
-    Object.assign(this, options);
-  }
-}
-
-export type PuzzleGeometryOptions = Partial<PuzzleGeometryFullOptions>;
-
-export function parsePGOptionList(optionlist?: any[]): PuzzleGeometryOptions {
-  const options: PuzzleGeometryOptions = {};
-  if (optionlist !== undefined) {
-    if (optionlist.length % 2 !== 0) {
-      throw new Error("Odd length in option list?");
-    }
-    for (let i = 0; i < optionlist.length; i += 2) {
-      if (optionlist[i] === "verbose") {
-        options.verbosity = (options.verbosity ?? 0) + 1;
-      } else if (optionlist[i] === "quiet") {
-        options.verbosity = 0;
-      } else if (optionlist[i] === "allmoves") {
-        options.allMoves = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "outerblockmoves") {
-        options.outerBlockMoves = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "vertexmoves") {
-        options.vertexMoves = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "rotations") {
-        options.addRotations = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "cornersets") {
-        options.includeCornerOrbits = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "centersets") {
-        options.includeCenterOrbits = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "edgesets") {
-        options.includeEdgeOrbits = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "omit") {
-        options.excludeOrbits = optionlist[i + 1];
-      } else if (optionlist[i] === "graycorners") {
-        options.grayCorners = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "graycenters") {
-        options.grayCenters = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "grayedges") {
-        options.grayEdges = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "movelist") {
-        options.moveList = asstructured(optionlist[i + 1]);
-      } else if (optionlist[i] === "killorientation") {
-        options.fixedOrientation = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "optimize") {
-        options.optimizeOrbits = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "scramble") {
-        options.scrambleAmount = optionlist[i + 1];
-      } else if (optionlist[i] === "fix") {
-        options.fixedPieceType = optionlist[i + 1];
-      } else if (optionlist[i] === "orientcenters") {
-        options.orientCenters = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "puzzleorientation") {
-        options.puzzleOrientation = asstructured(optionlist[i + 1]);
-      } else if (optionlist[i] === "puzzleorientations") {
-        options.puzzleOrientations = asstructured(optionlist[i + 1]);
-      } else {
-        throw new Error(
-          "Bad option while processing option list " + optionlist[i],
-        );
-      }
-    }
-  }
-  return options;
-}

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

@@ -1,127 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-import { getPuzzleGeometryByDesc } from ".";
-import { PGPuzzles } from "./PGPuzzles";
-import { transformationOrder, Transformation } from "../kpuzzle";
-import { TreeAlgIndexer, KSolvePuzzle } from "../twisty";
-import { Alg, Move } from "../alg";
-/**
- *   Test basic things about puzzles created by puzzle
- *   geometry.  We check stickers per face, face count
- *   (and thus total stickers), move count, orbit
- *   count, and cubie count.
- */
-const expectedData: { [nam: string]: string } = {
-  "2x2x2": "2x2x2, 6, 4, 8, 1, 6, 12",
-  "3x3x3": "3x3x3, 6, 9, 26, 3, 9, 120",
-  "4x4x4": "4x4x4, 6, 16, 56, 3, 12, 420",
-  "5x5x5": "5x5x5, 6, 25, 98, 6, 15, 840",
-  "6x6x6": "6x6x6, 6, 36, 152, 7, 18, 420",
-  "7x7x7": "7x7x7, 6, 49, 218, 11, 21, 840",
-  "8x8x8": "8x8x8, 6, 64, 296, 13, 24, 420",
-  "9x9x9": "9x9x9, 6, 81, 386, 18, 27, 840",
-  "10x10x10": "10x10x10, 6, 100, 488, 21, 30, 420",
-  "11x11x11": "11x11x11, 6, 121, 602, 27, 33, 840",
-  "12x12x12": "12x12x12, 6, 144, 728, 31, 36, 420",
-  "13x13x13": "13x13x13, 6, 169, 866, 38, 39, 840",
-  "20x20x20": "20x20x20, 6, 400, 2168, 91, 60, 420",
-  "30x30x30": "30x30x30, 6, 900, 5048, 211, 90, 420",
-  "40x40x40": "40x40x40, 6, 1600, 9128, 381, 120, 420",
-  "skewb": "skewb, 6, 5, 14, 3, 8, 9",
-  "master skewb": "master skewb, 6, 13, 50, 6, 12, 2520",
-  "professor skewb": "professor skewb, 6, 25, 110, 11, 16, 360",
-  "compy cube": "compy cube, 6, 9, 26, 4, 12, 42",
-  "helicopter": "helicopter, 6, 8, 32, 2, 18, 18",
-  "curvy copter": "curvy copter, 6, 13, 50, 4, 18, 18",
-  "dino": "dino, 6, 4, 12, 1, 12, 7",
-  "little chop": "little chop, 6, 4, 24, 1, 12, 5",
-  "pyramorphix": "pyramorphix, 4, 4, 8, 2, 6, 3",
-  "mastermorphix": "mastermorphix, 4, 10, 26, 8, 9, 6",
-  "pyraminx": "pyraminx, 4, 9, 14, 3, 12, 45",
-  "tetraminx": "tetraminx, 4, 6, 10, 2, 8, 45",
-  "master pyraminx": "master pyraminx, 4, 16, 30, 5, 16, 18",
-  "master tetraminx": "master tetraminx, 4, 13, 26, 4, 12, 90",
-  "professor pyraminx": "professor pyraminx, 4, 25, 54, 7, 20, 90",
-  "professor tetraminx": "professor tetraminx, 4, 22, 50, 6, 16, 90",
-  "Jing pyraminx": "Jing pyraminx, 4, 7, 14, 3, 8, 45",
-  "master pyramorphix": "master pyramorphix, 4, 10, 26, 8, 9, 6",
-  "megaminx": "megaminx, 12, 11, 62, 3, 18, 702",
-  "gigaminx": "gigaminx, 12, 31, 242, 6, 30, 18181800",
-  "teraminx": "teraminx, 12, 61, 542, 11, 42, 18181800",
-  "petaminx": "petaminx, 12, 101, 962, 18, 54, 18181800",
-  "examinx": "examinx, 12, 151, 1502, 27, 66, 18181800",
-  "zetaminx": "zetaminx, 12, 211, 2162, 38, 78, 18181800",
-  "yottaminx": "yottaminx, 12, 281, 2942, 51, 90, 18181800",
-  "pentultimate": "pentultimate, 12, 6, 32, 2, 12, 132",
-  "master pentultimate": "master pentultimate, 12, 16, 122, 4, 18, 1741740",
-  "elite pentultimate": "elite pentultimate, 12, 31, 272, 6, 24, 6832980",
-  "starminx": "starminx, 12, 11, 62, 3, 30, 48",
-  "starminx 2": "starminx 2, 12, 11, 102, 3, 18, 158340",
-  "pyraminx crystal": "pyraminx crystal, 12, 10, 50, 2, 18, 9828",
-  "chopasaurus": "chopasaurus, 12, 11, 92, 3, 20, 115710",
-  "big chop": "big chop, 12, 10, 120, 2, 30, 31668",
-  "skewb diamond": "skewb diamond, 8, 4, 14, 3, 8, 6",
-  "FTO": "FTO, 8, 9, 42, 4, 12, 990",
-  "master FTO": "master FTO, 8, 16, 86, 9, 16, 330",
-  "Christopher's jewel": "Christopher's jewel, 8, 6, 18, 2, 9, 120",
-  "octastar": "octastar, 8, 6, 24, 1, 12, 168",
-  "Trajber's octahedron": "Trajber's octahedron, 8, 7, 26, 3, 9, 120",
-  "radio chop": "radio chop, 20, 10, 92, 3, 20, 41580",
-  "icosamate": "icosamate, 20, 4, 32, 2, 12, 780",
-  "icosahedron 2": "icosahedron 2, 20, 9, 102, 3, 18, 12240",
-  "icosahedron 3": "icosahedron 3, 20, 18, 360, 6, 48, 2162160",
-  "icosahedron static faces":
-    "icosahedron static faces, 20, 7, 62, 3, 18, 6300",
-  "icosahedron moving faces":
-    "icosahedron moving faces, 20, 7, 62, 3, 18, 107100",
-  "Eitan's star": "Eitan's star, 20, 13, 152, 4, 30, 384560",
-  "2x2x2 + dino": "2x2x2 + dino, 6, 8, 24, 1, 18, 70",
-  "2x2x2 + little chop": "2x2x2 + little chop, 6, 8, 48, 2, 18, 168",
-  "dino + little chop": "dino + little chop, 6, 4, 24, 1, 24, 280",
-  "2x2x2 + dino + little chop":
-    "2x2x2 + dino + little chop, 6, 8, 48, 2, 30, 2340",
-  "megaminx + chopasaurus": "megaminx + chopasaurus, 12, 11, 92, 3, 38, 2610",
-  "starminx combo": "starminx combo, 12, 11, 102, 3, 48, 664020",
-};
-describe("PuzzleGeometry-Puzzles", () => {
-  it("testpuzzles", () => {
-    for (const [name, desc] of Object.entries(PGPuzzles)) {
-      const pg = getPuzzleGeometryByDesc(desc, {});
-      const kpuzzledef = pg.writekpuzzle(false);
-      const sep = ", ";
-      const seq = Object.getOwnPropertyNames(kpuzzledef.moves).sort().join(" ");
-      let algo = Alg.fromString(seq);
-      // TODO:  likely a temporary hack until we resolve how notations are
-      // added or set in puzzle geometry.
-      const bms = [];
-      for (const move of algo.units()) {
-        bms.push(pg.notationMapper.notationToExternal(move as Move) as Move);
-      }
-      // console.log(algo.toString(), bms);
-      algo = new Alg(bms);
-      const ksp = new KSolvePuzzle(kpuzzledef);
-      const tai = new TreeAlgIndexer(ksp, algo);
-      const tr = tai.transformAtIndex(tai.numAnimatedLeaves());
-      const o = transformationOrder(kpuzzledef, tr as Transformation);
-      const dat = [
-        name,
-        sep,
-        pg.baseplanerot.length,
-        sep,
-        pg.stickersperface,
-        sep,
-        pg.cubies.length,
-        sep,
-        Object.getOwnPropertyNames(kpuzzledef.orbits).length,
-        sep,
-        Object.getOwnPropertyNames(kpuzzledef.moves).length,
-        sep,
-        o,
-      ].join("");
-      const exp = expectedData[name];
-      expect(dat).toBe(exp);
-    }
-  });
-});

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

@@ -1,80 +0,0 @@
-export type PuzzleDescriptionString = string;
-
-export const PGPuzzles: { [name: string]: PuzzleDescriptionString } = {
-  "2x2x2": "c f 0",
-  "3x3x3": "c f 0.333333333333333",
-  "4x4x4": "c f 0.5 f 0",
-  "5x5x5": "c f 0.6 f 0.2",
-  "6x6x6": "c f 0.666666666666667 f 0.333333333333333 f 0",
-  "7x7x7": "c f 0.714285714285714 f 0.428571428571429 f 0.142857142857143",
-  "8x8x8": "c f 0.75 f 0.5 f 0.25 f 0",
-  "9x9x9":
-    "c f 0.777777777777778 f 0.555555555555556 f 0.333333333333333 f 0.111111111111111",
-  "10x10x10": "c f 0.8 f 0.6 f 0.4 f 0.2 f 0",
-  "11x11x11":
-    "c f 0.818181818181818 f 0.636363636363636 f 0.454545454545455 f 0.272727272727273 f 0.0909090909090909",
-  "12x12x12":
-    "c f 0.833333333333333 f 0.666666666666667 f 0.5 f 0.333333333333333 f 0.166666666666667 f 0",
-  "13x13x13":
-    "c f 0.846153846153846 f 0.692307692307692 f 0.538461538461538 f 0.384615384615385 f 0.230769230769231 f 0.0769230769230769",
-  "20x20x20": "c f 0 f .1 f .2 f .3 f .4 f .5 f .6 f .7 f .8 f .9",
-  "30x30x30":
-    "c f 0 f .066667 f .133333 f .2 f .266667 f .333333 f .4 f .466667 f .533333 f .6 f .666667 f .733333 f .8 f .866667 f .933333",
-  "40x40x40":
-    "c f 0 f .05 f .1 f .15 f .2 f .25 f .3 f .35 f .4 f .45 f .5 f .55 f .6 f .65 f .7 f .75 f .8 f .85 f .9 f .95",
-  "skewb": "c v 0",
-  "master skewb": "c v 0.275",
-  "professor skewb": "c v 0 v 0.38",
-  "compy cube": "c v 0.915641442663986",
-  "helicopter": "c e 0.707106781186547",
-  "curvy copter": "c e 0.83",
-  "dino": "c v 0.577350269189626",
-  "little chop": "c e 0",
-  "pyramorphix": "t e 0",
-  "mastermorphix": "t e 0.346184634065199",
-  "pyraminx": "t v 0.333333333333333 v 1.66666666666667",
-  "tetraminx": "t v 0.333333333333333",
-  "master pyraminx": "t v 0 v 1 v 2",
-  "master tetraminx": "t v 0 v 1",
-  "professor pyraminx": "t v -0.2 v 0.6 v 1.4 v 2.2",
-  "professor tetraminx": "t v -0.2 v 0.6 v 1.4",
-  "Jing pyraminx": "t f 0",
-  "master pyramorphix": "t e 0.866025403784437",
-  "megaminx": "d f 0.7",
-  "gigaminx": "d f 0.64 f 0.82",
-  "teraminx": "d f 0.64 f 0.76 f 0.88",
-  "petaminx": "d f 0.64 f 0.73 f 0.82 f 0.91",
-  "examinx": "d f 0.64 f 0.712 f 0.784 f 0.856 f 0.928",
-  "zetaminx": "d f 0.64 f 0.7 f 0.76 f 0.82 f 0.88 f 0.94",
-  "yottaminx": "d f 0.64 f 0.6914 f 0.7429 f 0.7943 f 0.8457 f 0.8971 f 0.9486",
-  "pentultimate": "d f 0",
-  "master pentultimate": "d f 0.1",
-  "elite pentultimate": "d f 0 f 0.145905",
-  // exact value for starminx is sqrt(5(5-2 sqrt(5))/3)
-  "starminx": "d v 0.937962370425399",
-  "starminx 2": "d f 0.23606797749979",
-  "pyraminx crystal": "d f 0.447213595499989",
-  "chopasaurus": "d v 0",
-  "big chop": "d e 0",
-  "skewb diamond": "o f 0",
-  "FTO": "o f 0.333333333333333",
-  "master FTO": "o f 0.5 f 0",
-  "Christopher's jewel": "o v 0.577350269189626",
-  "octastar": "o e 0",
-  "Trajber's octahedron": "o v 0.433012701892219",
-  "radio chop": "i f 0",
-  "icosamate": "i v 0",
-  "icosahedron 2": "i v 0.18759247376021",
-  "icosahedron 3": "i v 0.18759247376021 e 0",
-  "icosahedron static faces": "i v 0.84",
-  "icosahedron moving faces": "i v 0.73",
-  "Eitan's star": "i f 0.61803398874989",
-  "2x2x2 + dino": "c f 0 v 0.577350269189626",
-  "2x2x2 + little chop": "c f 0 e 0",
-  "dino + little chop": "c v 0.577350269189626 e 0",
-  "2x2x2 + dino + little chop": "c f 0 v 0.577350269189626 e 0",
-  "megaminx + chopasaurus": "d f 0.61803398875 v 0",
-  "starminx combo": "d f 0.23606797749979 v 0.937962370425399",
-};
-
-export type PuzzleName = keyof typeof PGPuzzles;

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

@@ -1,154 +0,0 @@
-const zeroCache: number[][] = [];
-const iotaCache: number[][] = [];
-
-export function zeros(n: number): number[] {
-  if (!zeroCache[n]) {
-    const c = Array(n);
-    for (let i = 0; i < n; i++) {
-      c[i] = 0;
-    }
-    zeroCache[n] = c;
-  }
-  return zeroCache[n];
-}
-
-export function iota(n: number): number[] {
-  if (!iotaCache[n]) {
-    const c = Array(n);
-    for (let i = 0; i < n; i++) {
-      c[i] = i;
-    }
-    iotaCache[n] = c;
-  }
-  return iotaCache[n];
-}
-
-export function identity(n: number): Perm {
-  return new Perm(iota(n));
-}
-
-export function random(n: number): Perm {
-  // random
-  const c = Array(n);
-  for (let i = 0; i < n; i++) {
-    c[i] = i;
-  }
-  for (let i = 0; i < n; i++) {
-    const j = i + Math.floor((n - i) * Math.random());
-    const t = c[i];
-    c[i] = c[j];
-    c[j] = t;
-  }
-  return new Perm(c);
-}
-
-export function factorial(a: number): number {
-  let r = 1;
-  while (a > 1) {
-    r *= a;
-    a--;
-  }
-  return r;
-}
-
-function gcd(a: number, b: number): number {
-  if (a > b) {
-    const t = a;
-    a = b;
-    b = t;
-  }
-  while (a > 0) {
-    const m = b % a;
-    b = a;
-    a = m;
-  }
-  return b;
-}
-
-export function lcm(a: number, b: number): number {
-  return (a / gcd(a, b)) * b;
-}
-
-export class Perm {
-  public n: number; // length
-  public p: number[]; // The permutation itself
-  constructor(a: number[]) {
-    this.n = a.length;
-    this.p = a;
-  }
-
-  public toString(): string {
-    // stringify
-    return "Perm[" + this.p.join(" ") + "]";
-  }
-
-  public mul(p2: Perm): Perm {
-    // multiply
-    const c: number[] = Array(this.n);
-    for (let i = 0; i < this.n; i++) {
-      c[i] = p2.p[this.p[i]];
-    }
-    return new Perm(c);
-  }
-
-  public rmul(p2: Perm): Perm {
-    // multiply the other way
-    const c = Array(this.n);
-    for (let i = 0; i < this.n; i++) {
-      c[i] = this.p[p2.p[i]];
-    }
-    return new Perm(c);
-  }
-
-  public inv(): Perm {
-    const c = Array(this.n);
-    for (let i = 0; i < this.n; i++) {
-      c[this.p[i]] = i;
-    }
-    return new Perm(c);
-  }
-
-  public compareTo(p2: Perm): number {
-    // comparison
-    for (let i = 0; i < this.n; i++) {
-      if (this.p[i] !== p2.p[i]) {
-        return this.p[i] - p2.p[i];
-      }
-    }
-    return 0;
-  }
-
-  public toGap(): string {
-    const cyc = new Array<string>();
-    const seen = new Array<boolean>(this.n);
-    for (let i = 0; i < this.p.length; i++) {
-      if (seen[i] || this.p[i] === i) {
-        continue;
-      }
-      const incyc = new Array<number>();
-      for (let j = i; !seen[j]; j = this.p[j]) {
-        incyc.push(1 + j);
-        seen[j] = true;
-      }
-      cyc.push("(" + incyc.join(",") + ")");
-    }
-    return cyc.join("");
-  }
-
-  public order(): number {
-    let r = 1;
-    const seen = new Array<boolean>(this.n);
-    for (let i = 0; i < this.p.length; i++) {
-      if (seen[i] || this.p[i] === i) {
-        continue;
-      }
-      let cs = 0;
-      for (let j = i; !seen[j]; j = this.p[j]) {
-        cs++;
-        seen[j] = true;
-      }
-      r = lcm(r, cs);
-    }
-    return r;
-  }
-}