@thi.ng/fuzzy 2.1.51 → 2.1.53

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-03T12:13:31Z
+- **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/defuzz.js

@@ -1,56 +1,40 @@
 import { constant, intersect, union, weighted } from "./shapes.js";
 import { centroidStrategy } from "./strategies/centroid.js";
 import { snormMax, tnormMin } from "./tnorms.js";
-/**
- * Takes an object of input {@link variable}s, an object of output variable,
- * rule array and an object of input values. Evaluates relevant terms of input
- * variables in all matching rules, then combines and defuzzes them using given
- * optional strategy (by default {@link centroidStrategy} w/ its own default
- * options). Returns object of computed output variable values.
- *
- * @remarks
- * The `imply` T-norm (default: {@link tnormMin} is used to transform each
- * rule's output set(s) using each rule's computed/aggregated truth value, as
- * well as each rule's weight. Different T-norms might produce different fuzzy
- * set shapes and different results, even if the defuzz strategy remains
- * constant.
- *
- * The `combine` S-norm (default: {@link snormMax}) is used to combine the
- * relevant output sets of all rules for integration/analysis by the given
- * defuzz `strategy` actually producing the crisp result.
- *
- * @param ins -
- * @param outs -
- * @param rules -
- * @param vals -
- * @param strategy -
- * @param imply -
- * @param combine -
- */
-export const defuzz = (ins, outs, rules, vals, strategy = centroidStrategy(), imply = tnormMin, combine = snormMax) => {
-    const ruleTerms = rules.map((r) => {
-        let alpha = null;
-        for (let id in vals) {
-            if (r.if[id]) {
-                const v = ins[id].terms[r.if[id]](vals[id]);
-                alpha = alpha !== null ? r.op(alpha, v) : v;
-            }
-        }
-        const terms = {};
-        if (alpha) {
-            const aterm = constant(alpha);
-            for (let id in r.then) {
-                if (outs[id]) {
-                    const oterm = outs[id].terms[r.then[id]];
-                    terms[id] = intersect(imply, r.weight == 1 ? oterm : weighted(oterm, r.weight), aterm);
-                }
-            }
+const defuzz = (ins, outs, rules, vals, strategy = centroidStrategy(), imply = tnormMin, combine = snormMax) => {
+  const ruleTerms = rules.map((r) => {
+    let alpha = null;
+    for (let id in vals) {
+      if (r.if[id]) {
+        const v = ins[id].terms[r.if[id]](vals[id]);
+        alpha = alpha !== null ? r.op(alpha, v) : v;
+      }
+    }
+    const terms = {};
+    if (alpha) {
+      const aterm = constant(alpha);
+      for (let id in r.then) {
+        if (outs[id]) {
+          const oterm = outs[id].terms[r.then[id]];
+          terms[id] = intersect(
+            imply,
+            r.weight == 1 ? oterm : weighted(oterm, r.weight),
+            aterm
+          );
         }
-        return terms;
-    });
-    const res = {};
-    for (let id in outs) {
-        res[id] = strategy(union(combine, ...ruleTerms.map((r) => r[id]).filter((f) => !!f)), outs[id].domain);
+      }
     }
-    return res;
+    return terms;
+  });
+  const res = {};
+  for (let id in outs) {
+    res[id] = strategy(
+      union(combine, ...ruleTerms.map((r) => r[id]).filter((f) => !!f)),
+      outs[id].domain
+    );
+  }
+  return res;
+};
+export {
+  defuzz
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/fuzzy",
-  "version": "2.1.51",
+  "version": "2.1.53",
   "description": "Fuzzy logic operators & configurable rule inferencing engine",
   "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 strategies",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,12 +35,12 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.10",
-    "@thi.ng/math": "^5.7.5"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/math": "^5.7.7"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
-    "@thi.ng/testament": "^0.4.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -104,5 +106,5 @@
   "thi.ng": {
     "year": 2020
   },
-  "gitHead": "04d1de79f256d7a53c6b5fd157b37f49bc88e11d\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/rules.js

@@ -1,44 +1,16 @@
 import { snormMax, tnormMin, tnormProduct } from "./tnorms.js";
-/**
- * Defines and returns a new rule object. Takes a T-norm (or S-norm) `op`, an
- * object of input conditions, an object of results and optional rule `weight`.
- * The `op` function is used to combine input terms.
- *
- * @remarks
- * The input and output objects are each using LVar names as keys and respective
- * var terms (their names) as values (see example).
- *
- * The optional rule weight (default: 1) is used by {@link defuzz} to adjust
- * rule importance.
- *
- * Also @see {@link and}, {@link strongAnd}, {@link or} for syntax sugar.
- *
- * @example
- * ```ts
- * // given 3 LVars from a classic fuzzy logic example:
- * // food, service, tip
- *
- * // define this rule:
- * // "If the food was bad AND service poor, then a small tip only"
- * // here multiply is used for strong conjunction of the food & service terms
- * rule(
- *   (a, b) => a * b,
- *   { food: "bad",  service: "poor" },
- *   { tip: "small" }
- * )
- * ```
- *
- * @param op -
- * @param $if
- * @param then -
- * @param weight -
- */
-export const rule = (op, $if, then, weight = 1) => ({
-    if: $if,
-    then,
-    op,
-    weight,
+const rule = (op, $if, then, weight = 1) => ({
+  if: $if,
+  then,
+  op,
+  weight
 });
-export const and = ($if, then, weight) => rule(tnormMin, $if, then, weight);
-export const strongAnd = ($if, then, weight) => rule(tnormProduct, $if, then, weight);
-export const or = ($if, then, weight) => rule(snormMax, $if, then, weight);
+const and = ($if, then, weight) => rule(tnormMin, $if, then, weight);
+const strongAnd = ($if, then, weight) => rule(tnormProduct, $if, then, weight);
+const or = ($if, then, weight) => rule(snormMax, $if, then, weight);
+export {
+  and,
+  or,
+  rule,
+  strongAnd
+};

package/shapes.js

@@ -2,195 +2,55 @@ import { EPS } from "@thi.ng/math/api";
 import { eqDelta } from "@thi.ng/math/eqdelta";
 import { fit, fitClamped } from "@thi.ng/math/fit";
 import { gaussian as $gaussian, sigmoid as $sigmoid } from "@thi.ng/math/mix";
-/**
- * HOF {@link FuzzyFn} always yielding given `x` (should be in [0,1]
- * interval).
- *
- * @param x -
- */
-export const constant = (x) => () => x;
-/**
- * HOF {@link FuzzyFn} which takes a value `p` and tolerance `eps`, then yields
- * a discrete window function: `|p - x| <= eps ? 1 : 0`
- *
- * @param p -
- * @param eps -
- */
-export const point = (p, eps = EPS) => (x) => eqDelta(x, p, eps) ? 1 : 0;
-/**
- * HOF {@link FuzzyFn} yielding a rising ramp in [a,b] interval, clamped to
- * [0,1] outputs. Returns 0.0 for inputs <= `a` and 1.0 for inputs >= `b`.
- *
- * @param a -
- * @param b -
- */
-export const ramp = (a, b) => (x) => fitClamped(x, a, b, 0, 1);
-/**
- * HOF {@link FuzzyFn} yielding a triangle in the input range `[a..b..c]` with
- * `b` defining the position of the peak value (1.0). Returns 0.0 for inputs <
- * `a` or > `c`.
- *
- * @param a -
- * @param b -
- * @param c -
- */
-export const triangle = (a, b, c) => (x) => x < a || x > c ? 0 : x <= b ? fit(x, a, b, 0, 1) : fit(x, b, c, 1, 0);
-/**
- * Similar to {@link triangle}, but yielding a trapezoid for the input range
- * `[a..b..c..d]` with `b` and `c` defining the peak value range (with 1.0
- * outputs). Returns 0.0 for inputs < `a` or > `d`.
- *
- * @param a -
- * @param b -
- * @param c -
- * @param d -
- */
-export const trapezoid = (a, b, c, d) => (x) => x < a || x > d
-    ? 0
-    : x > b && x < c
-        ? 1
-        : x <= b
-            ? fit(x, a, b, 0, 1)
-            : fit(x, c, d, 1, 0);
-/**
- * HOF {@link FuzzyFn}, yielding sigmoid curve with configurable `steep` and
- * positioned such that `f(bias) = 0.5`.
- *
- * @param bias -
- * @param steep -
- */
-export const sigmoid = (bias, steep) => (x) => $sigmoid(bias, steep, x);
-/**
- * HOF {@link FuzzyFn}, yielding gaussian bell curve with its peak at `bias` and
- * width defined by `sigma`.
- *
- * @param bias -
- * @param sigma -
- */
-export const gaussian = (bias, sigma) => (x) => $gaussian(bias, sigma, x);
-/**
- * Higher-order function: Takes an existing {@link FuzzyFn} `fn` and returns
- * a new one producing its negated outcome aka `1 - fn(x)`.
- *
- * @param fn -
- */
-export const negate = (fn) => (x) => 1 - fn(x);
-/**
- * Inverse of {@link ramp}, i.e. a falling slope from `a` -> `b`.
- *
- * @param a -
- * @param b -
- */
-export const invRamp = (a, b) => negate(ramp(a, b));
-/**
- * Inverse of {@link sigmoid}.
- *
- * @param bias -
- * @param steep -
- */
-export const invSigmoid = (bias, steep) => negate(sigmoid(bias, steep));
-/**
- * Higher-order function: Takes an existing {@link FuzzyFn} `fn` and `weight`
- * factor. Returns new function which computes: `weight * fn(x)`.
- *
- * @param fn -
- * @param weight -
- */
-export const weighted = (fn, weight) => (x) => weight * fn(x);
-/**
- * Higher order function. Returns new function which selects subset of given
- * fuzzy set where `fn(x) > alpha`, or else returns 0.
- *
- * @param fn -
- * @param alpha -
- */
-export const alphaCut = (fn, alpha = 0.5) => (x) => {
-    const y = fn(x);
-    return y > alpha ? y : 0;
+const constant = (x) => () => x;
+const point = (p, eps = EPS) => (x) => eqDelta(x, p, eps) ? 1 : 0;
+const ramp = (a, b) => (x) => fitClamped(x, a, b, 0, 1);
+const triangle = (a, b, c) => (x) => x < a || x > c ? 0 : x <= b ? fit(x, a, b, 0, 1) : fit(x, b, c, 1, 0);
+const trapezoid = (a, b, c, d) => (x) => x < a || x > d ? 0 : x > b && x < c ? 1 : x <= b ? fit(x, a, b, 0, 1) : fit(x, c, d, 1, 0);
+const sigmoid = (bias, steep) => (x) => $sigmoid(bias, steep, x);
+const gaussian = (bias, sigma) => (x) => $gaussian(bias, sigma, x);
+const negate = (fn) => (x) => 1 - fn(x);
+const invRamp = (a, b) => negate(ramp(a, b));
+const invSigmoid = (bias, steep) => negate(sigmoid(bias, steep));
+const weighted = (fn, weight) => (x) => weight * fn(x);
+const alphaCut = (fn, alpha = 0.5) => (x) => {
+  const y = fn(x);
+  return y > alpha ? y : 0;
 };
-/**
- * Higher order function. Returns new function which selects subset of given
- * fuzzy set where `fn(x) < alpha`, or else returns 0.
- *
- * @param fn -
- * @param alpha -
- */
-export const invAlphaCut = (fn, alpha = 0.5) => (x) => {
-    const y = fn(x);
-    return y < alpha ? y : 0;
+const invAlphaCut = (fn, alpha = 0.5) => (x) => {
+  const y = fn(x);
+  return y < alpha ? y : 0;
 };
-/**
- * Higher order function, complex shape generator. Takes a T-norm (or S-norm) as
- * reduction function `op` and any number of {@link FuzzyFn}s. Returns new
- * `FuzzyFn` which evaluates all given `fns` and combines/reduces their results
- * with `op`.
- *
- * @remarks
- * Depending on the use case and choice of `op`, the `initial` value should
- * either be set to:
- *
- * - T-norm like function: 1.0
- * - S-norm like function: 0.0
- *
- * References:
- * - https://www.desmos.com/calculator/pnq6kqzfb5 (interactive graph)
- * - https://en.wikipedia.org/wiki/T-norm
- * - https://github.com/thi-ng/umbrella/blob/develop/packages/fuzzy/src/tnorms.ts
- *
- * @example
- * ```ts
- * const f = compose(tnormMin, 1, triangle(0,2,4), triangle(1,3,5));
- * f(1); // 0
- * f(2); // 0.5
- * f(3); // 0.5
- * f(4); // 0
- * ```
- *
- * @example
- * ```ts
- * // M-like shape w/ peaks at 3 & 5
- * const M = compose(
- *   Math.max,
- *   0,
- *   triangle(1,3,5),
- *   triangle(3,5,7)
- * )
- *
- * M(3) // 1
- * M(4) // 0.5
- * M(5) // 1
- * ```
- *
- * @param op -
- * @param initial -
- * @param fns -
- */
-export const compose = (op, initial, ...fns) => {
-    const [a, b] = fns;
-    switch (fns.length) {
-        case 0:
-            throw new Error("no fuzzy sets given");
-        case 1:
-            return a;
-        case 2:
-            return (x) => op(a(x), b(x));
-        default:
-            return (x) => fns.reduce((acc, f) => op(acc, f(x)), initial);
-    }
+const compose = (op, initial, ...fns) => {
+  const [a, b] = fns;
+  switch (fns.length) {
+    case 0:
+      throw new Error("no fuzzy sets given");
+    case 1:
+      return a;
+    case 2:
+      return (x) => op(a(x), b(x));
+    default:
+      return (x) => fns.reduce((acc, f) => op(acc, f(x)), initial);
+  }
+};
+const intersect = (op, ...fns) => compose(op, 1, ...fns);
+const union = (op, ...fns) => compose(op, 0, ...fns);
+export {
+  alphaCut,
+  compose,
+  constant,
+  gaussian,
+  intersect,
+  invAlphaCut,
+  invRamp,
+  invSigmoid,
+  negate,
+  point,
+  ramp,
+  sigmoid,
+  trapezoid,
+  triangle,
+  union,
+  weighted
 };
-/**
- * Syntax sugar for {@link compose} with an initial value of 1.0. The `op` is
- * supposed to be a T-norm.
- *
- * @param op -
- * @param fns -
- */
-export const intersect = (op, ...fns) => compose(op, 1, ...fns);
-/**
- * Syntax sugar for {@link compose} with an initial value of 0.0. The `op` is
- * supposed to be a S-norm.
- *
- * @param op -
- * @param fns -
- */
-export const union = (op, ...fns) => compose(op, 0, ...fns);

package/strategies/bisector.js

@@ -1,52 +1,31 @@
 import { fit } from "@thi.ng/math/fit";
 import { defaultOpts } from "./opts.js";
-/**
- * Higher-order function: Bisector-of-Area defuzzification strategy. Returns
- * strategy which computes the integral of a given fuzzy set in the defined
- * `[min,max]` domain and returns the position of the bisector which partitions
- * the area into 2 equal halves. The domain is sampled at `opts.samples`
- * uniformly spaced points.
- *
- * @remarks
- * Use `samples` option to adjust precision.
- *
- * @see {@Link DefuzzStrategyOpts}
- *
- * @example
- * ```ts
- * bisectorStrategy()(trapezoid(0,1,5,6), [0,6])
- * // 2.97
- *
- * // ......▁█████████████|█████████████▁.....
- * // ......██████████████|██████████████.....
- * // .....███████████████|███████████████....
- * // ....▇███████████████|███████████████▇...
- * // ...▅████████████████|████████████████▅..
- * // ..▃█████████████████|█████████████████▃.
- * // .▁██████████████████|██████████████████▁
- * // .███████████████████|███████████████████
- * //                     ^ 2.97
- * ```
- *
- * @param opts -
- */
-export const bisectorStrategy = (opts) => {
-    let { samples } = defaultOpts(opts);
-    return (fn, [min, max]) => {
-        const delta = (max - min) / samples;
-        let sum = [];
-        for (let i = 0, acc = 0; i <= samples; i++) {
-            acc += fn(min + i * delta);
-            sum.push(acc);
-        }
-        if (!sum.length)
-            return min;
-        const mean = sum[samples] * 0.5;
-        for (let i = 1; i <= samples; i++) {
-            if (sum[i] >= mean) {
-                return fit(mean, sum[i - 1], sum[i], min + (i - 1) * delta, min + i * delta);
-            }
-        }
-        return min;
-    };
+const bisectorStrategy = (opts) => {
+  let { samples } = defaultOpts(opts);
+  return (fn, [min, max]) => {
+    const delta = (max - min) / samples;
+    let sum = [];
+    for (let i = 0, acc = 0; i <= samples; i++) {
+      acc += fn(min + i * delta);
+      sum.push(acc);
+    }
+    if (!sum.length)
+      return min;
+    const mean = sum[samples] * 0.5;
+    for (let i = 1; i <= samples; i++) {
+      if (sum[i] >= mean) {
+        return fit(
+          mean,
+          sum[i - 1],
+          sum[i],
+          min + (i - 1) * delta,
+          min + i * delta
+        );
+      }
+    }
+    return min;
+  };
+};
+export {
+  bisectorStrategy
 };

package/strategies/centroid.js

@@ -1,46 +1,19 @@
 import { defaultOpts } from "./opts.js";
-/**
- * Higher-order function: Centre-of-gravity defuzzification strategy, yielding
- * the approx. center of gravity position of a given fuzzy set. The domain is
- * sampled at `opts.samples` uniformly spaced points.
- *
- * @remarks
- * This is the default strategy used by {@link defuzz}. Produces similar results
- * to {@link bisectorStrategy}, but with lower computational cost. Use `samples`
- * option to adjust precision.
- *
- * @see {@Link DefuzzStrategyOpts}
- *
- * @example
- * ```ts
- * centroidStrategy()(trapezoid(0,1,5,6), [0,6])
- * // 3.0000000000000004
- *
- * // ......▁█████████████|█████████████▁.....
- * // ......██████████████|██████████████.....
- * // .....███████████████|███████████████....
- * // ....▇███████████████|███████████████▇...
- * // ...▅████████████████|████████████████▅..
- * // ..▃█████████████████|█████████████████▃.
- * // .▁██████████████████|██████████████████▁
- * // .███████████████████|███████████████████
- * //                     ^ 3.00
- * ```
- *
- * @param opts -
- */
-export const centroidStrategy = (opts) => {
-    let { samples } = defaultOpts(opts);
-    return (fn, [min, max]) => {
-        const delta = (max - min) / samples;
-        let num = 0;
-        let denom = 0;
-        for (let i = 0; i <= samples; i++) {
-            const x = min + i * delta;
-            const y = fn(x);
-            num += x * y;
-            denom += y;
-        }
-        return num / denom;
-    };
+const centroidStrategy = (opts) => {
+  let { samples } = defaultOpts(opts);
+  return (fn, [min, max]) => {
+    const delta = (max - min) / samples;
+    let num = 0;
+    let denom = 0;
+    for (let i = 0; i <= samples; i++) {
+      const x = min + i * delta;
+      const y = fn(x);
+      num += x * y;
+      denom += y;
+    }
+    return num / denom;
+  };
+};
+export {
+  centroidStrategy
 };

package/strategies/maxima.js

@@ -1,129 +1,50 @@
 import { eqDelta } from "@thi.ng/math/eqdelta";
 import { defaultOpts } from "./opts.js";
-/**
- * Higher-order function. Returns Mean-of-Maxima defuzzification strategy,
- * yielding the approx. mean of the maximum region of a given fuzzy set.
- *
- * @remarks
- * Use `samples` option to adjust precision.
- *
- * @see {@Link DefuzzStrategyOpts}
- *
- * @example
- * ```ts
- * meanOfMaximaStrategy()(trapezoid(0,1,5,6), [0,6])
- * // 3
- *
- * // ......▁█████████████|█████████████▁.....
- * // ......██████████████|██████████████.....
- * // .....███████████████|███████████████....
- * // ....▇███████████████|███████████████▇...
- * // ...▅████████████████|████████████████▅..
- * // ..▃█████████████████|█████████████████▃.
- * // .▁██████████████████|██████████████████▁
- * // .███████████████████|███████████████████
- * //                     ^ 3.00
- * ```
- *
- * @param opts -
- */
-export const meanOfMaximaStrategy = (opts) => {
-    const { samples, eps } = defaultOpts(opts);
-    return (fn, [min, max]) => {
-        const delta = (max - min) / samples;
-        let peak = -Infinity;
-        let peakPos = min;
-        let n = 1;
-        for (let i = 0; i <= samples; i++) {
-            const t = min + i * delta;
-            const x = fn(t);
-            if (eqDelta(x, peak, eps)) {
-                peakPos += t;
-                n++;
-            }
-            else if (x > peak) {
-                peak = x;
-                peakPos = t;
-                n = 1;
-            }
-        }
-        return peakPos / n;
-    };
+const meanOfMaximaStrategy = (opts) => {
+  const { samples, eps } = defaultOpts(opts);
+  return (fn, [min, max]) => {
+    const delta = (max - min) / samples;
+    let peak = -Infinity;
+    let peakPos = min;
+    let n = 1;
+    for (let i = 0; i <= samples; i++) {
+      const t = min + i * delta;
+      const x = fn(t);
+      if (eqDelta(x, peak, eps)) {
+        peakPos += t;
+        n++;
+      } else if (x > peak) {
+        peak = x;
+        peakPos = t;
+        n = 1;
+      }
+    }
+    return peakPos / n;
+  };
 };
-/**
- * Higher-order function. Returns First-of-Maxima defuzzification strategy,
- * yielding the approx. start position of the maximum region of a given fuzzy
- * set.
- *
- * @remarks
- * Use `samples` option to adjust precision.
- *
- * @see {@Link DefuzzStrategyOpts}
- *
- * @example
- * ```ts
- * firstOfMaximaStrategy()(trapezoid(0,1,5,6), [0,6])
- * // 1.02
- *
- * // ......▁|██████████████████████████▁.....
- * // ......█|███████████████████████████.....
- * // .....██|████████████████████████████....
- * // ....▇██|████████████████████████████▇...
- * // ...▅███|█████████████████████████████▅..
- * // ..▃████|██████████████████████████████▃.
- * // .▁█████|███████████████████████████████▁
- * // .██████|████████████████████████████████
- * //        ^ 1.02
- * ```
- *
- * @param opts -
- */
-export const firstOfMaximaStrategy = (opts) => {
-    const { samples } = defaultOpts(opts);
-    return (fn, [min, max]) => {
-        const delta = (max - min) / samples;
-        let peak = -Infinity;
-        let peakPos = min;
-        for (let i = 0; i <= samples; i++) {
-            const t = min + i * delta;
-            const x = fn(t);
-            if (x > peak) {
-                peak = x;
-                peakPos = t;
-            }
-        }
-        return peakPos;
-    };
+const firstOfMaximaStrategy = (opts) => {
+  const { samples } = defaultOpts(opts);
+  return (fn, [min, max]) => {
+    const delta = (max - min) / samples;
+    let peak = -Infinity;
+    let peakPos = min;
+    for (let i = 0; i <= samples; i++) {
+      const t = min + i * delta;
+      const x = fn(t);
+      if (x > peak) {
+        peak = x;
+        peakPos = t;
+      }
+    }
+    return peakPos;
+  };
 };
-/**
- * Higher-order function. Returns Last-of-Maxima defuzzification strategy,
- * yielding the approx. final position of the maximum region of a given fuzzy
- * set.
- *
- * @remarks
- * Use `samples` option to adjust precision.
- *
- * @see {@Link DefuzzStrategyOpts}
- *
- * @example
- * ```ts
- * lastOfMaximaStrategy()(trapezoid(0,1,5,6), [0,6])
- * // 4.98
- *
- * // ......▁██████████████████████████|▁.....
- * // ......███████████████████████████|█.....
- * // .....████████████████████████████|██....
- * // ....▇████████████████████████████|██▇...
- * // ...▅█████████████████████████████|███▅..
- * // ..▃██████████████████████████████|████▃.
- * // .▁███████████████████████████████|█████▁
- * // .████████████████████████████████|██████
- * //                                  ^ 4.98
- * ```
- *
- * @param opts -
- */
-export const lastOfMaximaStrategy = (opts) => {
-    const impl = firstOfMaximaStrategy(opts);
-    return (fn, [min, max]) => impl(fn, [max, min]);
+const lastOfMaximaStrategy = (opts) => {
+  const impl = firstOfMaximaStrategy(opts);
+  return (fn, [min, max]) => impl(fn, [max, min]);
+};
+export {
+  firstOfMaximaStrategy,
+  lastOfMaximaStrategy,
+  meanOfMaximaStrategy
 };

package/strategies/opts.js

@@ -1,5 +1,8 @@
-export const defaultOpts = (opts) => ({
-    samples: 100,
-    eps: 1e-6,
-    ...opts,
+const defaultOpts = (opts) => ({
+  samples: 100,
+  eps: 1e-6,
+  ...opts
 });
+export {
+  defaultOpts
+};

package/tnorms.js

@@ -1,113 +1,46 @@
 import { norm } from "@thi.ng/math/fit";
 import { clamp0 } from "@thi.ng/math/interval";
-// https://en.wikipedia.org/wiki/T-norm
-export const tnormMin = (x, y) => Math.min(x, y);
-export const tnormProduct = (x, y) => x * y;
-export const tnormLukasiewicz = (x, y) => clamp0(x + y - 1);
-export const tnormDrastic = (x, y) => (x === 1 ? y : y === 1 ? x : 0);
-export const tnormNilpotent = (x, y) => (x + y > 1 ? Math.min(x, y) : 0);
-/**
- * HOF T-norm. Parametric Hamacher with `p` controlling curvature.
- *
- * @remarks
- * Interactive graph: https://www.desmos.com/calculator/4bneccqs3p
- *
- * @param p - curve param [0..∞], default: 2
- */
-export const tnormHamacher = (p = 2) => (x, y) => x === 0 && y === 0 ? 0 : (x * y) / (p + (1 - p) * (x + y - x * y));
-/**
- * HOF T-norm. Parametric Yager with `p` controlling curvature.
- *
- * @remarks
- * Interactive graph: https://www.desmos.com/calculator/4bneccqs3p
- *
- * @param p - curve param [0..∞], default: 2
- */
-export const tnormYager = (p = 2) => p === 0
-    ? () => 0
-    : (x, y) => clamp0(1 - ((1 - x) ** p + (1 - y) ** p) ** (1 / p));
-/**
- * HOF T-norm. Parametric Dombi with `p` controlling curvature.
- *
- * @remarks
- * Interactive graph: https://www.desmos.com/calculator/4bneccqs3p
- *
- * @param p - curve param [0..∞], default: 2
- */
-export const tnormDombi = (p = 2) => p === 0
-    ? () => 0
-    : (x, y) => x === 0 || y === 0
-        ? 0
-        : 1 /
-            (1 +
-                (((1 - x) / x) ** p + ((1 - y) / y) ** p) **
-                    (1 / p));
-/**
- * HOF T-norm. Parametric Aczél–Alsina with `p` controlling curvature.
- *
- * @remarks
- * Interactive graph: https://www.desmos.com/calculator/4bneccqs3p
- *
- * @param p - curve param [0..∞], default: 2
- */
-export const tnormAczelAlsina = (p = 2) => (x, y) => Math.exp(-((Math.abs(Math.log(x)) ** p + Math.abs(Math.log(y)) ** p) **
-    (1 / p)));
-/**
- * S-norm (T-conorm), dual of {@link tnormMin}.
- *
- * @param x -
- * @param y -
- */
-export const snormMax = (x, y) => Math.max(x, y);
-/**
- * S-norm (T-conorm), dual of {@link tnormProduct}, probabilistic sum:
- * `a + b - a * b`
- *
- * @param x -
- * @param y -
- */
-export const snormProbabilistic = (x, y) => x + y - x * y;
-/**
- * S-norm (T-conorm), dual of {@link tnormLukasiewicz}.
- *
- * @param x -
- * @param y -
- */
-export const snormBoundedSum = (x, y) => Math.min(x + y, 1);
-/**
- * S-norm (T-conorm), dual of {@link tnormDrastic}.
- */
-export const snormDrastic = (x, y) => (x === 0 ? y : y === 0 ? x : 1);
-/**
- * S-norm (T-conorm), dual of {@link tnormNilpotent}.
- *
- * @param x -
- * @param y -
- */
-export const snormNilpotent = (x, y) => (x + y < 1 ? Math.max(x, y) : 1);
-/**
- * S-norm (T-conorm), dual of {@link tnormHamacher}, iff that T-norm's curve
- * param is `p=2`.
- *
- * @param x -
- * @param y -
- */
-export const snormEinstein = (x, y) => (x + y) / (1 + x * y);
-/**
- * HOF t-norm. Constructs a new t-norm based on given t-norms for disjoint
- * subintervals, completing remaining regions via {@link min}.
- *
- * @remarks
- * Reference: https://en.wikipedia.org/wiki/Construction_of_t-norms#Ordinal_sums
- *
- * @param specs -
- */
-export const ordinalSum = (specs) => (x, y) => {
-    for (let s of specs) {
-        const [a, b] = s.domain;
-        if (x >= a && x <= b && y >= a && y <= b) {
-            return a + (b - a) * s.tnorm(norm(x, a, b), norm(y, a, b));
-        }
+const tnormMin = (x, y) => Math.min(x, y);
+const tnormProduct = (x, y) => x * y;
+const tnormLukasiewicz = (x, y) => clamp0(x + y - 1);
+const tnormDrastic = (x, y) => x === 1 ? y : y === 1 ? x : 0;
+const tnormNilpotent = (x, y) => x + y > 1 ? Math.min(x, y) : 0;
+const tnormHamacher = (p = 2) => (x, y) => x === 0 && y === 0 ? 0 : x * y / (p + (1 - p) * (x + y - x * y));
+const tnormYager = (p = 2) => p === 0 ? () => 0 : (x, y) => clamp0(1 - ((1 - x) ** p + (1 - y) ** p) ** (1 / p));
+const tnormDombi = (p = 2) => p === 0 ? () => 0 : (x, y) => x === 0 || y === 0 ? 0 : 1 / (1 + (((1 - x) / x) ** p + ((1 - y) / y) ** p) ** (1 / p));
+const tnormAczelAlsina = (p = 2) => (x, y) => Math.exp(
+  -((Math.abs(Math.log(x)) ** p + Math.abs(Math.log(y)) ** p) ** (1 / p))
+);
+const snormMax = (x, y) => Math.max(x, y);
+const snormProbabilistic = (x, y) => x + y - x * y;
+const snormBoundedSum = (x, y) => Math.min(x + y, 1);
+const snormDrastic = (x, y) => x === 0 ? y : y === 0 ? x : 1;
+const snormNilpotent = (x, y) => x + y < 1 ? Math.max(x, y) : 1;
+const snormEinstein = (x, y) => (x + y) / (1 + x * y);
+const ordinalSum = (specs) => (x, y) => {
+  for (let s of specs) {
+    const [a, b] = s.domain;
+    if (x >= a && x <= b && y >= a && y <= b) {
+      return a + (b - a) * s.tnorm(norm(x, a, b), norm(y, a, b));
     }
-    return Math.min(x, y);
+  }
+  return Math.min(x, y);
+};
+export {
+  ordinalSum,
+  snormBoundedSum,
+  snormDrastic,
+  snormEinstein,
+  snormMax,
+  snormNilpotent,
+  snormProbabilistic,
+  tnormAczelAlsina,
+  tnormDombi,
+  tnormDrastic,
+  tnormHamacher,
+  tnormLukasiewicz,
+  tnormMin,
+  tnormNilpotent,
+  tnormProduct,
+  tnormYager
 };

package/var.js

@@ -1,87 +1,28 @@
-/**
- * Takes a `domain` interval and on object of named fuzzy sets and returns a new
- * Linguistic variable, which can then be used as input or output var for
- * {@link defuzz}.
- *
- * @example
- * ```ts
- * // temperature sets (in celsius)
- * const temp = variable([-20, 40], {
- *   freezing: invSigmoid(0, 2),
- *   cold: trapezoid(0, 4, 16, 20),
- *   warm: trapezoid(15, 20, 25, 30),
- *   hot: sigmoid(30, 2)
- * });
- * ```
- *
- * @param domain -
- * @param terms -
- */
-export const variable = (domain, terms) => ({
-    domain,
-    terms,
+const variable = (domain, terms) => ({
+  domain,
+  terms
 });
-/**
- * Takes an LVar and a domain value `x`. Returns the ID of the var's fuzzy set
- * term which yields the max truth value for given `x`. If `threshold` is
- * enabled (default: 0.5), any truth value MUST also be > `threshold` to be
- * considered. The function returns undefined if classification failed.
- *
- * @example
- * ```ts
- * // temperature sets (in celsius)
- * const temp = variable([-20, 40], {
- *   freezing: invSigmoid(0, 2),
- *   cold: trapezoid(0, 4, 16, 20),
- *   warm: trapezoid(15, 20, 25, 30),
- *   hot: sigmoid(30, 2)
- * });
- *
- * classify(temp, 28)
- * // "warm"
- * ```
- *
- * @param var -
- * @param x -
- * @param threshold -
- */
-export const classify = ({ terms }, x, threshold = 0.5) => {
-    let max = threshold;
-    let maxID;
-    for (let id in terms) {
-        const t = terms[id](x);
-        if (t >= max) {
-            max = t;
-            maxID = id;
-        }
+const classify = ({ terms }, x, threshold = 0.5) => {
+  let max = threshold;
+  let maxID;
+  for (let id in terms) {
+    const t = terms[id](x);
+    if (t >= max) {
+      max = t;
+      maxID = id;
     }
-    return maxID;
+  }
+  return maxID;
 };
-/**
- * Takes an LVar and a domain value `x`, evaluates all of var's terms for given
- * `x` and returns object of results.
- *
- * @example
- * ```ts
- * // temperature sets (in celsius)
- * const temp = variable([-20, 40], {
- *   freezing: invSigmoid(0, 2),
- *   cold: trapezoid(0, 4, 16, 20),
- *   warm: trapezoid(15, 20, 25, 30),
- *   hot: sigmoid(30, 2)
- * });
- *
- * evaluate(temp, 28)
- * // { freezing: 0, cold: 0, warm: 0.4, hot: 0.01798620996209156 }
- * ```
- *
- * @param var -
- * @param x -
- */
-export const evaluate = ({ terms }, x) => {
-    const res = {};
-    for (let id in terms) {
-        res[id] = terms[id](x);
-    }
-    return res;
+const evaluate = ({ terms }, x) => {
+  const res = {};
+  for (let id in terms) {
+    res[id] = terms[id](x);
+  }
+  return res;
+};
+export {
+  classify,
+  evaluate,
+  variable
 };