@thi.ng/gp 0.4.81 → 0.4.82

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/api.js

@@ -1 +0,0 @@
-export {};

package/ast.js

@@ -6,134 +6,148 @@ import { repeatedly } from "@thi.ng/transducers/repeatedly";
 import { takeWhile } from "@thi.ng/transducers/take-while";
 import { zipper } from "@thi.ng/zipper/zipper";
 import { opNode, probabilities, terminalNode } from "./utils.js";
-export class AST {
-    opts;
-    choices;
-    probTerminal;
-    constructor(opts) {
-        this.opts = { rnd: SYSTEM, ...opts };
-        assert(this.opts.probMutate < 1, "mutation probability must be < 1.0");
-        const probs = probabilities(this.opts);
-        this.probTerminal = probs.probTerminal;
-        this.choices = probs.iter;
-    }
-    /**
-     * Returns a random AST with given max tree depth. The max depth
-     * provided in {@link ASTOpts} is used by default.
-     *
-     * @param maxDepth -
-     */
-    randomAST(maxDepth = this.opts.maxDepth) {
-        return this.randomASTNode(0, maxDepth);
-    }
-    /**
-     * Immutably transplants a randomly chosen subtree of `parent2` into
-     * a randomly chosen location in `parent1` and vice versa. Returns 2
-     * new trees.
-     *
-     * @param parent1 -
-     * @param parent2 -
-     */
-    crossoverSingle(parent1, parent2) {
-        return [
-            this.selectRandomNode(parent1).replace(this.selectRandomNode(parent2).node).root,
-            this.selectRandomNode(parent2).replace(this.selectRandomNode(parent1).node).root,
-        ];
-    }
-    /**
-     * Probilistically replaces randomly chosen tree nodes with a new random AST
-     * of given `maxDepth` (default: 1). Never mutates root.
-     *
-     * @remarks
-     * The AST's pre-configured max tree depth will always be respected, so
-     * depending on the depth of the selected mutation location, the randomly
-     * inserted/replaced subtree might be more shallow than given `maxDepth`.
-     * I.e. if a tree node at max depth is selected for mutation, it will always
-     * result in a randomly chosen terminal node only.
-     *
-     * @param tree -
-     * @param maxDepth -
-     */
-    mutate(tree, maxDepth = 1) {
-        const { rnd, probMutate, maxDepth: limit } = this.opts;
-        let loc = this.asZipper(tree).next;
-        if (!loc)
-            return tree;
-        while (true) {
-            let nextLoc;
-            if (rnd.probability(probMutate)) {
-                loc = loc.replace(this.randomASTNode(0, Math.min(limit - loc.depth, maxDepth)));
-                nextLoc = loc.right;
-                if (!nextLoc) {
-                    nextLoc = loc.up;
-                    if (nextLoc) {
-                        nextLoc = nextLoc.right;
-                    }
-                }
-            }
-            else {
-                nextLoc = loc.next;
-            }
-            if (!nextLoc)
-                return loc.root;
-            loc = nextLoc;
+class AST {
+  opts;
+  choices;
+  probTerminal;
+  constructor(opts) {
+    this.opts = { rnd: SYSTEM, ...opts };
+    assert(this.opts.probMutate < 1, "mutation probability must be < 1.0");
+    const probs = probabilities(this.opts);
+    this.probTerminal = probs.probTerminal;
+    this.choices = probs.iter;
+  }
+  /**
+   * Returns a random AST with given max tree depth. The max depth
+   * provided in {@link ASTOpts} is used by default.
+   *
+   * @param maxDepth -
+   */
+  randomAST(maxDepth = this.opts.maxDepth) {
+    return this.randomASTNode(0, maxDepth);
+  }
+  /**
+   * Immutably transplants a randomly chosen subtree of `parent2` into
+   * a randomly chosen location in `parent1` and vice versa. Returns 2
+   * new trees.
+   *
+   * @param parent1 -
+   * @param parent2 -
+   */
+  crossoverSingle(parent1, parent2) {
+    return [
+      this.selectRandomNode(parent1).replace(
+        this.selectRandomNode(parent2).node
+      ).root,
+      this.selectRandomNode(parent2).replace(
+        this.selectRandomNode(parent1).node
+      ).root
+    ];
+  }
+  /**
+   * Probilistically replaces randomly chosen tree nodes with a new random AST
+   * of given `maxDepth` (default: 1). Never mutates root.
+   *
+   * @remarks
+   * The AST's pre-configured max tree depth will always be respected, so
+   * depending on the depth of the selected mutation location, the randomly
+   * inserted/replaced subtree might be more shallow than given `maxDepth`.
+   * I.e. if a tree node at max depth is selected for mutation, it will always
+   * result in a randomly chosen terminal node only.
+   *
+   * @param tree -
+   * @param maxDepth -
+   */
+  mutate(tree, maxDepth = 1) {
+    const { rnd, probMutate, maxDepth: limit } = this.opts;
+    let loc = this.asZipper(tree).next;
+    if (!loc)
+      return tree;
+    while (true) {
+      let nextLoc;
+      if (rnd.probability(probMutate)) {
+        loc = loc.replace(
+          this.randomASTNode(0, Math.min(limit - loc.depth, maxDepth))
+        );
+        nextLoc = loc.right;
+        if (!nextLoc) {
+          nextLoc = loc.up;
+          if (nextLoc) {
+            nextLoc = nextLoc.right;
+          }
         }
+      } else {
+        nextLoc = loc.next;
+      }
+      if (!nextLoc)
+        return loc.root;
+      loc = nextLoc;
     }
-    /**
-     * Returns linearized/flat version of given AST as an array of [zipper
-     * locations](https://docs.thi.ng/umbrella/zipper/classes/Location.html).
-     *
-     * @param tree -
-     */
-    linearizedAST(tree) {
-        return [
-            ...iterator(takeWhile((x) => !!x), iterate((x) => x.next, this.asZipper(tree))),
-        ];
-    }
-    /**
-     * Returns random {@link ASTNode} from given tree, using the user provided
-     * PRNG (via `opts`) or
-     * [`SYSTEM`](https://docs.thi.ng/umbrella/random/variables/SYSTEM.html).
-     * The returned value is a [zipper
-     * location](https://docs.thi.ng/umbrella/zipper/classes/Location.html) of
-     * the selected node.
-     *
-     * @remarks
-     * The actual `ASTNode` can be obtained via `.node`.
-     *
-     * Only nodes in the linearized index range `[min..max)` are returned
-     * (default: entire tree range). Since the linear tree length isn't known
-     * beforehand, `max` < 0 (default) is equivalent to the linearized tree end.
-     *
-     * @param opts -
-     * @param tree -
-     * @param min -
-     * @param max -
-     */
-    selectRandomNode(tree, min = 0, max = -1) {
-        const rnd = this.opts.rnd;
-        const linTree = this.linearizedAST(tree);
-        let node;
-        max < 0 && (max = linTree.length);
-        node = linTree[rnd.minmax(min, max) | 0];
-        return node;
-    }
-    randomASTNode(d, maxDepth) {
-        const rnd = this.opts.rnd;
-        const geneID = this.choices.next().value;
-        if (geneID === 0 || d >= maxDepth)
-            return terminalNode(this.opts.terminal(rnd));
-        const op = this.opts.ops[geneID - 1];
-        const children = [
-            ...repeatedly(() => this.randomASTNode(d + 1, maxDepth), op.arity),
-        ];
-        return opNode(op.fn(rnd, children), children);
-    }
-    asZipper(tree) {
-        return zipper({
-            branch: (x) => x.type === "op",
-            children: (x) => x.args,
-            factory: (n, args) => opNode(n.op, args),
-        }, tree);
-    }
+  }
+  /**
+   * Returns linearized/flat version of given AST as an array of [zipper
+   * locations](https://docs.thi.ng/umbrella/zipper/classes/Location.html).
+   *
+   * @param tree -
+   */
+  linearizedAST(tree) {
+    return [
+      ...iterator(
+        takeWhile((x) => !!x),
+        iterate((x) => x.next, this.asZipper(tree))
+      )
+    ];
+  }
+  /**
+   * Returns random {@link ASTNode} from given tree, using the user provided
+   * PRNG (via `opts`) or
+   * [`SYSTEM`](https://docs.thi.ng/umbrella/random/variables/SYSTEM.html).
+   * The returned value is a [zipper
+   * location](https://docs.thi.ng/umbrella/zipper/classes/Location.html) of
+   * the selected node.
+   *
+   * @remarks
+   * The actual `ASTNode` can be obtained via `.node`.
+   *
+   * Only nodes in the linearized index range `[min..max)` are returned
+   * (default: entire tree range). Since the linear tree length isn't known
+   * beforehand, `max` < 0 (default) is equivalent to the linearized tree end.
+   *
+   * @param opts -
+   * @param tree -
+   * @param min -
+   * @param max -
+   */
+  selectRandomNode(tree, min = 0, max = -1) {
+    const rnd = this.opts.rnd;
+    const linTree = this.linearizedAST(tree);
+    let node;
+    max < 0 && (max = linTree.length);
+    node = linTree[rnd.minmax(min, max) | 0];
+    return node;
+  }
+  randomASTNode(d, maxDepth) {
+    const rnd = this.opts.rnd;
+    const geneID = this.choices.next().value;
+    if (geneID === 0 || d >= maxDepth)
+      return terminalNode(this.opts.terminal(rnd));
+    const op = this.opts.ops[geneID - 1];
+    const children = [
+      ...repeatedly(() => this.randomASTNode(d + 1, maxDepth), op.arity)
+    ];
+    return opNode(op.fn(rnd, children), children);
+  }
+  asZipper(tree) {
+    return zipper(
+      {
+        branch: (x) => x.type === "op",
+        children: (x) => x.args,
+        factory: (n, args) => opNode(n.op, args)
+      },
+      tree
+    );
+  }
 }
+export {
+  AST
+};

package/mep.js

@@ -2,104 +2,98 @@ import { inRange } from "@thi.ng/math/interval";
 import { SYSTEM } from "@thi.ng/random/system";
 import { repeatedly } from "@thi.ng/transducers/repeatedly";
 import { opNode, probabilities, terminalNode } from "./utils.js";
-export class MEP {
-    opts;
-    probTerminal;
-    choices;
-    constructor(opts) {
-        this.opts = { rnd: SYSTEM, ...opts };
-        const probs = probabilities(this.opts);
-        this.probTerminal = probs.probTerminal;
-        this.choices = probs.iter;
+class MEP {
+  opts;
+  probTerminal;
+  choices;
+  constructor(opts) {
+    this.opts = { rnd: SYSTEM, ...opts };
+    const probs = probabilities(this.opts);
+    this.probTerminal = probs.probTerminal;
+    this.choices = probs.iter;
+  }
+  /**
+   * Returns a new random {@link MEPChromosome} with the configured
+   * probabilities of operator and terminal nodes (constants).
+   *
+   * @remarks
+   * See {@link MEP.decodeChromosome} for conversion to
+   * {@link ASTNode}s.
+   *
+   */
+  randomChromosome() {
+    const res = [];
+    for (let i = 0, n = this.opts.chromoSize; i < n; i++) {
+      res[i] = this.randomGene(i);
     }
-    /**
-     * Returns a new random {@link MEPChromosome} with the configured
-     * probabilities of operator and terminal nodes (constants).
-     *
-     * @remarks
-     * See {@link MEP.decodeChromosome} for conversion to
-     * {@link ASTNode}s.
-     *
-     */
-    randomChromosome() {
-        const res = [];
-        for (let i = 0, n = this.opts.chromoSize; i < n; i++) {
-            res[i] = this.randomGene(i);
-        }
-        return res;
+    return res;
+  }
+  /**
+   * Decodes given chromosome into an array of {@link ASTNode}s and
+   * optionally applies tree depth filter (by default includes all).
+   *
+   * @remarks
+   * A {@link MEPChromosome} encodes multiple solutions (one per gene
+   * slot), therefore a chromosome of length `n` will produce the same
+   * number ASTs (less if min/max tree depth filters are applied).
+   *
+   * @param chromosome -
+   * @param minDepth -
+   * @param maxDepth -
+   */
+  decodeChromosome(chromosome, minDepth = 0, maxDepth = Infinity) {
+    const res = [];
+    const depths = [];
+    for (let i = 0; i < chromosome.length; i++) {
+      const gene = chromosome[i];
+      if (gene.type == "term") {
+        res[i] = gene;
+        depths[i] = 1;
+      } else {
+        res[i] = opNode(
+          gene.op,
+          gene.args.map((g) => res[g])
+        );
+        depths[i] = 1 + gene.args.reduce((d, a) => Math.max(d, depths[a]), 0);
+      }
     }
-    /**
-     * Decodes given chromosome into an array of {@link ASTNode}s and
-     * optionally applies tree depth filter (by default includes all).
-     *
-     * @remarks
-     * A {@link MEPChromosome} encodes multiple solutions (one per gene
-     * slot), therefore a chromosome of length `n` will produce the same
-     * number ASTs (less if min/max tree depth filters are applied).
-     *
-     * @param chromosome -
-     * @param minDepth -
-     * @param maxDepth -
-     */
-    decodeChromosome(chromosome, minDepth = 0, maxDepth = Infinity) {
-        const res = [];
-        const depths = [];
-        for (let i = 0; i < chromosome.length; i++) {
-            const gene = chromosome[i];
-            if (gene.type == "term") {
-                res[i] = gene;
-                depths[i] = 1;
-            }
-            else {
-                res[i] = opNode(gene.op, gene.args.map((g) => res[g]));
-                depths[i] =
-                    1 + gene.args.reduce((d, a) => Math.max(d, depths[a]), 0);
-            }
-        }
-        return res.filter((_, i) => inRange(depths[i], minDepth, maxDepth));
+    return res.filter((_, i) => inRange(depths[i], minDepth, maxDepth));
+  }
+  crossoverSingle(chromo1, chromo2, cut) {
+    cut = cut !== void 0 ? cut : this.opts.rnd.int() % Math.min(chromo1.length, chromo2.length);
+    return [
+      chromo1.slice(0, cut).concat(chromo2.slice(cut)),
+      chromo2.slice(0, cut).concat(chromo1.slice(cut))
+    ];
+  }
+  crossoverUniform(chromo1, chromo2) {
+    const rnd = this.opts.rnd;
+    const res = [];
+    const minLen = Math.min(chromo1.length, chromo2.length);
+    for (let i = 0; i < minLen; i++) {
+      res[i] = rnd.probability(0.5) ? chromo1[i] : chromo2[i];
     }
-    crossoverSingle(chromo1, chromo2, cut) {
-        cut =
-            cut !== undefined
-                ? cut
-                : this.opts.rnd.int() %
-                    Math.min(chromo1.length, chromo2.length);
-        return [
-            chromo1.slice(0, cut).concat(chromo2.slice(cut)),
-            chromo2.slice(0, cut).concat(chromo1.slice(cut)),
-        ];
+    return chromo1.length > minLen ? res.concat(chromo1.slice(minLen)) : chromo2.length > minLen ? res.concat(chromo2.slice(minLen)) : res;
+  }
+  mutate(chromo) {
+    const { rnd, probMutate } = this.opts;
+    const res = new Array(chromo.length);
+    for (let i = chromo.length; i-- > 0; ) {
+      res[i] = rnd.probability(probMutate) ? this.randomGene(i) : chromo[i];
     }
-    crossoverUniform(chromo1, chromo2) {
-        const rnd = this.opts.rnd;
-        const res = [];
-        const minLen = Math.min(chromo1.length, chromo2.length);
-        for (let i = 0; i < minLen; i++) {
-            res[i] = rnd.probability(0.5) ? chromo1[i] : chromo2[i];
-        }
-        return chromo1.length > minLen
-            ? res.concat(chromo1.slice(minLen))
-            : chromo2.length > minLen
-                ? res.concat(chromo2.slice(minLen))
-                : res;
-    }
-    mutate(chromo) {
-        const { rnd, probMutate } = this.opts;
-        const res = new Array(chromo.length);
-        for (let i = chromo.length; i-- > 0;) {
-            res[i] = rnd.probability(probMutate)
-                ? this.randomGene(i)
-                : chromo[i];
-        }
-        return res;
-    }
-    randomGene(i) {
-        const geneID = this.choices.next().value;
-        const rnd = this.opts.rnd;
-        if (i === 0 || geneID === 0) {
-            return terminalNode(this.opts.terminal(rnd));
-        }
-        const op = this.opts.ops[geneID - 1];
-        const args = [...repeatedly(() => rnd.int() % i, op.arity)];
-        return opNode(op.fn(rnd, args), args);
+    return res;
+  }
+  randomGene(i) {
+    const geneID = this.choices.next().value;
+    const rnd = this.opts.rnd;
+    if (i === 0 || geneID === 0) {
+      return terminalNode(this.opts.terminal(rnd));
     }
+    const op = this.opts.ops[geneID - 1];
+    const args = [...repeatedly(() => rnd.int() % i, op.arity)];
+    return opNode(op.fn(rnd, args), args);
+  }
 }
+export {
+  MEP
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/gp",
-  "version": "0.4.81",
+  "version": "0.4.82",
   "description": "Genetic programming helpers & strategies (tree based & multi-expression programming)",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,15 +35,16 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/errors": "^2.4.5",
-    "@thi.ng/math": "^5.7.6",
-    "@thi.ng/random": "^3.6.17",
-    "@thi.ng/transducers": "^8.8.14",
-    "@thi.ng/zipper": "^2.1.68"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/math": "^5.7.7",
+    "@thi.ng/random": "^3.6.18",
+    "@thi.ng/transducers": "^8.8.15",
+    "@thi.ng/zipper": "^2.1.69"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -106,5 +109,5 @@
     "status": "alpha",
     "year": 2019
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/utils.js

@@ -1,23 +1,31 @@
-// thing:no-export
 import { assert } from "@thi.ng/errors/assert";
 import { add } from "@thi.ng/transducers/add";
 import { choices } from "@thi.ng/transducers/choices";
 import { range } from "@thi.ng/transducers/range";
-export const terminalNode = (value) => ({
-    type: "term",
-    value,
+const terminalNode = (value) => ({
+  type: "term",
+  value
 });
-export const opNode = (op, args) => ({
-    type: "op",
-    op,
-    args,
+const opNode = (op, args) => ({
+  type: "op",
+  op,
+  args
 });
-export const probabilities = (opts) => {
-    const probabilities = opts.ops.map((op) => op.prob);
-    const psum = add(probabilities);
-    assert(psum < 1, "total op probabilities MUST be < 1");
-    return {
-        iter: choices([...range(probabilities.length + 1)], [1 - psum, ...probabilities], opts.rnd),
-        probTerminal: 1 - psum,
-    };
+const probabilities = (opts) => {
+  const probabilities2 = opts.ops.map((op) => op.prob);
+  const psum = add(probabilities2);
+  assert(psum < 1, "total op probabilities MUST be < 1");
+  return {
+    iter: choices(
+      [...range(probabilities2.length + 1)],
+      [1 - psum, ...probabilities2],
+      opts.rnd
+    ),
+    probTerminal: 1 - psum
+  };
+};
+export {
+  opNode,
+  probabilities,
+  terminalNode
 };