@thi.ng/fuzzy 2.1.2 → 2.1.5

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2021-11-21T17:09:28Z
+- **Last updated**: 2022-04-07T14:17:30Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -351,4 +351,4 @@ If this project contributes to an academic publication, please cite it as:
 
 ## License
 
-© 2020 - 2021 Karsten Schmidt // Apache Software License 2.0
+© 2020 - 2022 Karsten Schmidt // Apache Software License 2.0

package/defuzz.d.ts

@@ -17,13 +17,13 @@ import type { LVarSet, Rule } from "./api.js";
  * 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
+ * @param ins -
+ * @param outs -
+ * @param rules -
+ * @param vals -
+ * @param strategy -
+ * @param imply -
+ * @param combine -
  */
 export declare const defuzz: <I extends LVarSet<string>, O extends LVarSet<string>>(ins: I, outs: O, rules: Rule<I, O>[], vals: Partial<Record<keyof I, number>>, strategy?: import("./api.js").DefuzzStrategy, imply?: import("@thi.ng/api").FnN2, combine?: import("@thi.ng/api").FnN2) => Partial<Record<keyof O, number>>;
 //# sourceMappingURL=defuzz.d.ts.map

package/defuzz.js

@@ -19,13 +19,13 @@ import { snormMax, tnormMin } from "./tnorms.js";
  * 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
+ * @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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/fuzzy",
-  "version": "2.1.2",
+  "version": "2.1.5",
   "description": "Fuzzy logic operators & configurable rule inferencing engine",
   "type": "module",
   "module": "./index.js",
@@ -34,16 +34,16 @@
     "test": "testament test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.3.2",
-    "@thi.ng/math": "^5.1.2"
+    "@thi.ng/api": "^8.3.5",
+    "@thi.ng/math": "^5.3.1"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.18.19",
-    "@thi.ng/testament": "^0.2.2",
+    "@microsoft/api-extractor": "^7.19.4",
+    "@thi.ng/testament": "^0.2.5",
     "rimraf": "^3.0.2",
     "tools": "^0.0.1",
-    "typedoc": "^0.22.9",
-    "typescript": "^4.5.2"
+    "typedoc": "^0.22.13",
+    "typescript": "^4.6.2"
   },
   "keywords": [
     "agent",
@@ -69,41 +69,41 @@
   ],
   "exports": {
     ".": {
-      "import": "./index.js"
+      "default": "./index.js"
     },
     "./api": {
-      "import": "./api.js"
+      "default": "./api.js"
     },
     "./defuzz": {
-      "import": "./defuzz.js"
+      "default": "./defuzz.js"
     },
     "./rules": {
-      "import": "./rules.js"
+      "default": "./rules.js"
     },
     "./shapes": {
-      "import": "./shapes.js"
+      "default": "./shapes.js"
     },
     "./strategies/bisector": {
-      "import": "./strategies/bisector.js"
+      "default": "./strategies/bisector.js"
     },
     "./strategies/centroid": {
-      "import": "./strategies/centroid.js"
+      "default": "./strategies/centroid.js"
     },
     "./strategies/maxima": {
-      "import": "./strategies/maxima.js"
+      "default": "./strategies/maxima.js"
     },
     "./strategies/opts": {
-      "import": "./strategies/opts.js"
+      "default": "./strategies/opts.js"
     },
     "./tnorms": {
-      "import": "./tnorms.js"
+      "default": "./tnorms.js"
     },
     "./var": {
-      "import": "./var.js"
+      "default": "./var.js"
     }
   },
   "thi.ng": {
     "year": 2020
   },
-  "gitHead": "e8a7c2a40191b391cef182c2978e5a6c85987a87\n"
+  "gitHead": "5ee1feb590dd935593b1dd4e7f38a3ed3ba64765\n"
 }

package/rules.d.ts

@@ -29,10 +29,10 @@ import type { LVarKeySet, LVarSet, Rule } from "./api.js";
  * )
  * ```
  *
- * @param op
+ * @param op -
  * @param $if
- * @param then
- * @param weight
+ * @param then -
+ * @param weight -
  */
 export declare const rule: <I extends LVarSet<string>, O extends LVarSet<string>>(op: FnN2, $if: Partial<{ [k in keyof I]: keyof I[k]["terms"]; }>, then: Partial<{ [k_1 in keyof O]: keyof O[k_1]["terms"]; }>, weight?: number) => Rule<I, O>;
 export declare const and: <I extends LVarSet<string>, O extends LVarSet<string>>($if: Partial<{ [k in keyof I]: keyof I[k]["terms"]; }>, then: Partial<{ [k_1 in keyof O]: keyof O[k_1]["terms"]; }>, weight?: number | undefined) => Rule<I, O>;

package/rules.js

@@ -28,10 +28,10 @@ import { snormMax, tnormMin, tnormProduct } from "./tnorms.js";
  * )
  * ```
  *
- * @param op
+ * @param op -
  * @param $if
- * @param then
- * @param weight
+ * @param then -
+ * @param weight -
  */
 export const rule = (op, $if, then, weight = 1) => ({
     if: $if,

package/shapes.d.ts

@@ -4,23 +4,23 @@ import type { FuzzyFn } from "./api.js";
  * HOF {@link FuzzyFn} always yielding given `x` (should be in [0,1]
  * interval).
  *
- * @param x
+ * @param x -
  */
 export declare const constant: (x: number) => FuzzyFn;
 /**
  * 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
+ * @param p -
+ * @param eps -
  */
 export declare const point: (p: number, eps?: number) => FuzzyFn;
 /**
  * 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
+ * @param a -
+ * @param b -
  */
 export declare const ramp: FnU2<number, FuzzyFn>;
 /**
@@ -28,9 +28,9 @@ export declare const ramp: FnU2<number, FuzzyFn>;
  * `b` defining the position of the peak value (1.0). Returns 0.0 for inputs <
  * `a` or > `c`.
  *
- * @param a
- * @param b
- * @param c
+ * @param a -
+ * @param b -
+ * @param c -
  */
 export declare const triangle: FnU3<number, FuzzyFn>;
 /**
@@ -38,71 +38,71 @@ export declare const triangle: FnU3<number, FuzzyFn>;
  * `[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
+ * @param a -
+ * @param b -
+ * @param c -
+ * @param d -
  */
 export declare const trapezoid: FnU4<number, FuzzyFn>;
 /**
  * HOF {@link FuzzyFn}, yielding sigmoid curve with configurable `steep` and
  * positioned such that `f(bias) = 0.5`.
  *
- * @param bias
- * @param steep
+ * @param bias -
+ * @param steep -
  */
 export declare const sigmoid: FnU2<number, FuzzyFn>;
 /**
  * HOF {@link FuzzyFn}, yielding gaussian bell curve with its peak at `bias` and
  * width defined by `sigma`.
  *
- * @param bias
- * @param sigma
+ * @param bias -
+ * @param sigma -
  */
 export declare const gaussian: FnU2<number, FuzzyFn>;
 /**
  * Higher-order function: Takes an existing {@link FuzzyFn} `fn` and returns
  * a new one producing its negated outcome aka `1 - fn(x)`.
  *
- * @param fn
+ * @param fn -
  */
 export declare const negate: FnU<FuzzyFn>;
 /**
  * Inverse of {@link ramp}, i.e. a falling slope from `a` -> `b`.
  *
- * @param a
- * @param b
+ * @param a -
+ * @param b -
  */
 export declare const invRamp: FnU2<number, FuzzyFn>;
 /**
  * Inverse of {@link sigmoid}.
  *
- * @param bias
- * @param steep
+ * @param bias -
+ * @param steep -
  */
 export declare const invSigmoid: FnU2<number, FuzzyFn>;
 /**
  * Higher-order function: Takes an existing {@link FuzzyFn} `fn` and `weight`
  * factor. Returns new function which computes: `weight * fn(x)`.
  *
- * @param fn
- * @param weight
+ * @param fn -
+ * @param weight -
  */
 export declare const weighted: (fn: FuzzyFn, weight: number) => FuzzyFn;
 /**
  * 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
+ * @param fn -
+ * @param alpha -
  */
 export declare const alphaCut: (fn: FuzzyFn, alpha?: number) => FuzzyFn;
 /**
  * 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
+ * @param fn -
+ * @param alpha -
  */
 export declare const invAlphaCut: (fn: FuzzyFn, alpha?: number) => FuzzyFn;
 /**
@@ -147,25 +147,25 @@ export declare const invAlphaCut: (fn: FuzzyFn, alpha?: number) => FuzzyFn;
  * M(5) // 1
  * ```
  *
- * @param op
- * @param initial
- * @param fns
+ * @param op -
+ * @param initial -
+ * @param fns -
  */
 export declare const compose: (op: FnN2, initial: number, ...fns: FuzzyFn[]) => FuzzyFn;
 /**
  * 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
+ * @param op -
+ * @param fns -
  */
 export declare const intersect: (op: FnN2, ...fns: FuzzyFn[]) => import("@thi.ng/api").FnN;
 /**
  * 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
+ * @param op -
+ * @param fns -
  */
 export declare const union: (op: FnN2, ...fns: FuzzyFn[]) => import("@thi.ng/api").FnN;
 //# sourceMappingURL=shapes.d.ts.map

package/shapes.js

@@ -6,23 +6,23 @@ 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
+ * @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
+ * @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
+ * @param a -
+ * @param b -
  */
 export const ramp = (a, b) => (x) => fitClamped(x, a, b, 0, 1);
 /**
@@ -30,9 +30,9 @@ export const ramp = (a, b) => (x) => fitClamped(x, a, b, 0, 1);
  * `b` defining the position of the peak value (1.0). Returns 0.0 for inputs <
  * `a` or > `c`.
  *
- * @param a
- * @param b
- * @param 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);
 /**
@@ -40,10 +40,10 @@ export const triangle = (a, b, c) => (x) => x < a || x > c ? 0 : x <= b ? fit(x,
  * `[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
+ * @param a -
+ * @param b -
+ * @param c -
+ * @param d -
  */
 export const trapezoid = (a, b, c, d) => (x) => x < a || x > d
     ? 0
@@ -56,53 +56,53 @@ export const trapezoid = (a, b, c, d) => (x) => x < a || x > d
  * HOF {@link FuzzyFn}, yielding sigmoid curve with configurable `steep` and
  * positioned such that `f(bias) = 0.5`.
  *
- * @param bias
- * @param steep
+ * @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
+ * @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
+ * @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
+ * @param a -
+ * @param b -
  */
 export const invRamp = (a, b) => negate(ramp(a, b));
 /**
  * Inverse of {@link sigmoid}.
  *
- * @param bias
- * @param steep
+ * @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
+ * @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
+ * @param fn -
+ * @param alpha -
  */
 export const alphaCut = (fn, alpha = 0.5) => (x) => {
     const y = fn(x);
@@ -112,8 +112,8 @@ export const alphaCut = (fn, alpha = 0.5) => (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
+ * @param fn -
+ * @param alpha -
  */
 export const invAlphaCut = (fn, alpha = 0.5) => (x) => {
     const y = fn(x);
@@ -161,9 +161,9 @@ export const invAlphaCut = (fn, alpha = 0.5) => (x) => {
  * M(5) // 1
  * ```
  *
- * @param op
- * @param initial
- * @param fns
+ * @param op -
+ * @param initial -
+ * @param fns -
  */
 export const compose = (op, initial, ...fns) => {
     const [a, b] = fns;
@@ -182,15 +182,15 @@ export const compose = (op, initial, ...fns) => {
  * 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
+ * @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
+ * @param op -
+ * @param fns -
  */
 export const union = (op, ...fns) => compose(op, 0, ...fns);

package/strategies/bisector.d.ts

@@ -27,7 +27,7 @@ import type { DefuzzStrategy, DefuzzStrategyOpts } from "../api.js";
  * //                     ^ 2.97
  * ```
  *
- * @param opts
+ * @param opts -
  */
 export declare const bisectorStrategy: (opts?: Partial<DefuzzStrategyOpts> | undefined) => DefuzzStrategy;
 //# sourceMappingURL=bisector.d.ts.map

package/strategies/bisector.js

@@ -28,7 +28,7 @@ import { defaultOpts } from "./opts.js";
  * //                     ^ 2.97
  * ```
  *
- * @param opts
+ * @param opts -
  */
 export const bisectorStrategy = (opts) => {
     let { samples } = defaultOpts(opts);

package/strategies/centroid.d.ts

@@ -27,7 +27,7 @@ import type { DefuzzStrategy, DefuzzStrategyOpts } from "../api.js";
  * //                     ^ 3.00
  * ```
  *
- * @param opts
+ * @param opts -
  */
 export declare const centroidStrategy: (opts?: Partial<DefuzzStrategyOpts> | undefined) => DefuzzStrategy;
 //# sourceMappingURL=centroid.d.ts.map

package/strategies/centroid.js

@@ -27,7 +27,7 @@ import { defaultOpts } from "./opts.js";
  * //                     ^ 3.00
  * ```
  *
- * @param opts
+ * @param opts -
  */
 export const centroidStrategy = (opts) => {
     let { samples } = defaultOpts(opts);

package/strategies/maxima.d.ts

@@ -24,7 +24,7 @@ import type { DefuzzStrategy, DefuzzStrategyOpts } from "../api.js";
  * //                     ^ 3.00
  * ```
  *
- * @param opts
+ * @param opts -
  */
 export declare const meanOfMaximaStrategy: (opts?: Partial<DefuzzStrategyOpts> | undefined) => DefuzzStrategy;
 /**
@@ -53,7 +53,7 @@ export declare const meanOfMaximaStrategy: (opts?: Partial<DefuzzStrategyOpts> |
  * //        ^ 1.02
  * ```
  *
- * @param opts
+ * @param opts -
  */
 export declare const firstOfMaximaStrategy: (opts?: Partial<DefuzzStrategyOpts> | undefined) => DefuzzStrategy;
 /**
@@ -82,7 +82,7 @@ export declare const firstOfMaximaStrategy: (opts?: Partial<DefuzzStrategyOpts>
  * //                                  ^ 4.98
  * ```
  *
- * @param opts
+ * @param opts -
  */
 export declare const lastOfMaximaStrategy: (opts?: Partial<DefuzzStrategyOpts> | undefined) => DefuzzStrategy;
 //# sourceMappingURL=maxima.d.ts.map

package/strategies/maxima.js

@@ -25,7 +25,7 @@ import { defaultOpts } from "./opts.js";
  * //                     ^ 3.00
  * ```
  *
- * @param opts
+ * @param opts -
  */
 export const meanOfMaximaStrategy = (opts) => {
     const { samples, eps } = defaultOpts(opts);
@@ -76,7 +76,7 @@ export const meanOfMaximaStrategy = (opts) => {
  * //        ^ 1.02
  * ```
  *
- * @param opts
+ * @param opts -
  */
 export const firstOfMaximaStrategy = (opts) => {
     const { samples } = defaultOpts(opts);
@@ -121,7 +121,7 @@ export const firstOfMaximaStrategy = (opts) => {
  * //                                  ^ 4.98
  * ```
  *
- * @param opts
+ * @param opts -
  */
 export const lastOfMaximaStrategy = (opts) => {
     const impl = firstOfMaximaStrategy(opts);

package/tnorms.d.ts

@@ -43,23 +43,23 @@ export declare const tnormAczelAlsina: (p?: number) => FnN2;
 /**
  * S-norm (T-conorm), dual of {@link tnormMin}.
  *
- * @param x
- * @param y
+ * @param x -
+ * @param y -
  */
 export declare const snormMax: FnN2;
 /**
  * S-norm (T-conorm), dual of {@link tnormProduct}, probabilistic sum:
  * `a + b - a * b`
  *
- * @param x
- * @param y
+ * @param x -
+ * @param y -
  */
 export declare const snormProbabilistic: FnN2;
 /**
  * S-norm (T-conorm), dual of {@link tnormLukasiewicz}.
  *
- * @param x
- * @param y
+ * @param x -
+ * @param y -
  */
 export declare const snormBoundedSum: FnN2;
 /**
@@ -69,16 +69,16 @@ export declare const snormDrastic: FnN2;
 /**
  * S-norm (T-conorm), dual of {@link tnormNilpotent}.
  *
- * @param x
- * @param y
+ * @param x -
+ * @param y -
  */
 export declare const snormNilpotent: FnN2;
 /**
  * S-norm (T-conorm), dual of {@link tnormHamacher}, iff that T-norm's curve
  * param is `p=2`.
  *
- * @param x
- * @param y
+ * @param x -
+ * @param y -
  */
 export declare const snormEinstein: FnN2;
 /**
@@ -88,7 +88,7 @@ export declare const snormEinstein: FnN2;
  * @remarks
  * Reference: https://en.wikipedia.org/wiki/Construction_of_t-norms#Ordinal_sums
  *
- * @param specs
+ * @param specs -
  */
 export declare const ordinalSum: (specs: {
     domain: Range;

package/tnorms.js

@@ -53,23 +53,23 @@ export const tnormAczelAlsina = (p = 2) => (x, y) => Math.exp(-((Math.abs(Math.l
 /**
  * S-norm (T-conorm), dual of {@link tnormMin}.
  *
- * @param x
- * @param y
+ * @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
+ * @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
+ * @param x -
+ * @param y -
  */
 export const snormBoundedSum = (x, y) => Math.min(x + y, 1);
 /**
@@ -79,16 +79,16 @@ export const snormDrastic = (x, y) => (x === 0 ? y : y === 0 ? x : 1);
 /**
  * S-norm (T-conorm), dual of {@link tnormNilpotent}.
  *
- * @param x
- * @param y
+ * @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
+ * @param x -
+ * @param y -
  */
 export const snormEinstein = (x, y) => (x + y) / (1 + x * y);
 /**
@@ -98,7 +98,7 @@ export const snormEinstein = (x, y) => (x + y) / (1 + x * y);
  * @remarks
  * Reference: https://en.wikipedia.org/wiki/Construction_of_t-norms#Ordinal_sums
  *
- * @param specs
+ * @param specs -
  */
 export const ordinalSum = (specs) => (x, y) => {
     for (let s of specs) {

package/var.d.ts

@@ -15,8 +15,8 @@ import type { LVar } from "./api.js";
  * });
  * ```
  *
- * @param domain
- * @param terms
+ * @param domain -
+ * @param terms -
  */
 export declare const variable: <K extends string>(domain: import("@thi.ng/api").Range, terms: import("./api.js").LVarTerms<K>) => LVar<K>;
 /**
@@ -39,9 +39,9 @@ export declare const variable: <K extends string>(domain: import("@thi.ng/api").
  * // "warm"
  * ```
  *
- * @param var
- * @param x
- * @param threshold
+ * @param var -
+ * @param x -
+ * @param threshold -
  */
 export declare const classify: <K extends string>({ terms }: LVar<K>, x: number, threshold?: number) => K | undefined;
 /**
@@ -62,8 +62,8 @@ export declare const classify: <K extends string>({ terms }: LVar<K>, x: number,
  * // { freezing: 0, cold: 0, warm: 0.4, hot: 0.01798620996209156 }
  * ```
  *
- * @param var
- * @param x
+ * @param var -
+ * @param x -
  */
 export declare const evaluate: <K extends string>({ terms }: LVar<K>, x: number) => Record<K, number>;
 //# sourceMappingURL=var.d.ts.map

package/var.js

@@ -14,8 +14,8 @@
  * });
  * ```
  *
- * @param domain
- * @param terms
+ * @param domain -
+ * @param terms -
  */
 export const variable = (domain, terms) => ({
     domain,
@@ -41,9 +41,9 @@ export const variable = (domain, terms) => ({
  * // "warm"
  * ```
  *
- * @param var
- * @param x
- * @param threshold
+ * @param var -
+ * @param x -
+ * @param threshold -
  */
 export const classify = ({ terms }, x, threshold = 0.5) => {
     let max = threshold;
@@ -75,8 +75,8 @@ export const classify = ({ terms }, x, threshold = 0.5) => {
  * // { freezing: 0, cold: 0, warm: 0.4, hot: 0.01798620996209156 }
  * ```
  *
- * @param var
- * @param x
+ * @param var -
+ * @param x -
  */
 export const evaluate = ({ terms }, x) => {
     const res = {};