es6-fuzz 4.0.0 → 5.0.0

package/Readme.md

@@ -5,7 +5,6 @@
 [![npm](https://img.shields.io/npm/dt/es6-fuzz.svg)](https://www.npmjs.com/package/es6-fuzz)
 [![license](https://img.shields.io/github/license/sebs/es6-fuzz.svg)](https://github.com/sebs/es6-fuzz/blob/master/LICENSE.md)
 [![GitHub tag](https://img.shields.io/github/tag/sebs/es6-fuzz.svg)](https://github.com/sebs/es6-fuzz)
-[![Travis](https://img.shields.io/travis/sebs/es6-fuzz.svg)](https://travis-ci.org/sebs/es6-fuzz)
 [![GitHub issues](https://img.shields.io/github/issues/sebs/es6-fuzz.svg)](https://github.com/sebs/es6-fuzz/issues)
 
 Supported fuzzyfiers
@@ -19,8 +18,8 @@ Supported fuzzyfiers
 * Triangle
 
 
-* [api docs](https://github.com/sebs/es6-fuzz)
-* [changelog](./docs/changelog.md)
+* [api docs](http://sebs.github.io/es6-fuzz)
+* [changelog](https://github.com/sebs/es6-fuzz/blob/master/docs/CHANGELOG.md)
 
 ## Install and Usage
 
@@ -58,6 +57,61 @@ var res = logic
 
 * hot
 
+
+## Usage with boon-js
+
+In order to combine 2 fuzzy functions with boolean logic, there is a compat layer for boon-js which allows the sauge of 'boolean expression language'. 
+
+Example of a monster biting when its cold and you are close to it: 
+ 
+
+Heat part:
+
+```js
+var logicHeat = new Logic();
+const optimalTemperature = new Triangle(10, 20, 30);
+const toColdTemperature = new Triangle(0, 10, 15);
+const toHotTemperature = new Triangle(25, 40, 60);
+
+logicHeat.init('cold', toColdTemperature)
+logicHeat.or('optimal', optimalTemperature)
+logicHeat.or('hot', toHotTemperature);
+```
+
+Distance Part
+
+```js
+
+var logicDistance = new Logic();
+const close = new Triangle(0, 10, 20);
+const far = new Triangle(5, 50, 100);
+
+logicDistance.init('close', close)
+logicDistance.or('far', far)
+
+```
+
+Now we marry the 2 and use boon js
+
+```js
+const monsterBiteTest = getEvaluator(
+    'heat.cold AND distance.close',
+);
+const resHeat = logicHeat.defuzzify(2, 'heat');
+const resClose = logicDistance.defuzzify(2, 'distance');
+
+const jsBoonInput = { ...resHeat.boonJsInputs, ...resClose.boonJsInputs }
+
+monsterBiteTest(jsBoonInput) 
+// returns true
+```
+
+    
+
+
+
+
+
 ## development
 
 **Tests** use mocha and a plugin for traceur

package/docs/CHANGELOG.md

@@ -1,6 +1,34 @@
+2025-06-26
+==========
+
+  * 5.0.0
+  * (churn): changelog
+  * 4.0.4
+  * fix: edge cases
+  * 4.0.3
+  * refactor: cleaned up test structure
+  * 4.0.2
+  * docs: add a clearer test case for constant
+  * fix: [#76](https://github.com/sebs/es6-fuzz/issues/76) sigmoid implementation with weird microoptimizations
+    * added a different sigmoid function with easier to understand parameters
+
+2023-01-18
+==========
+
+  * test: find the bug with trapezoid special form square
+
+2023-01-17
+==========
+
+  * test: more tests for the trapezoid
+
 2022-06-14
 ==========
 
+  * chore: link docs
+  * (churn): changelog
+  * 4.0.1
+  * fix: update readme
   * 4.0.0
   * feature: make the api work with boonJsInputs
   * feature: add a test for outoput names only to consist of alphabet
@@ -132,21 +160,3 @@
   * 2.6.0
   * Added link to api docs
   * More docs
-
-2017-04-04
-==========
-
-  * Added latest es5 export to dist
-  * (churn): changelog
-  * 2.5.10
-  * Added curves
-  * 2.5.9
-  * add missing dep
-  * 2.5.8
-  * Pages
-  * 2.5.7
-  * 2.5.6
-  * Added docs
-  * Fix output ght pages
-  * DOcs
-  * Ghpages

package/jsdoc.json

@@ -18,7 +18,6 @@
         "includePattern": ".+\\.js(doc)?$",
         "excludePattern": "(^|\\/|\\\\)_"
     },
-    "analytics":{"ua":"UA-85700100-2", "domain":"https://sebs.github.io/es6-fuzz/"},
     "plugins": [],
     "templates": {
       "cleverLinks": true,

package/lib/curve/grade.js

@@ -14,6 +14,13 @@ class Grade extends Shape {
   fuzzify(val) {
     let result = 0;
     const x = val;
+    
+    // Handle case where x0 = x1 (vertical grade/step function)
+    if (this.x1 === this.x0) {
+      if (x < this.x0) return 0;
+      return 1; // x >= x0
+    }
+    
     if (x <= this.x0) {
       result = 0;
     } else if (x >= this.x1) {

package/lib/curve/reverse-grade.js

@@ -16,7 +16,12 @@ class ReverseGrade extends Shape {
     } else if (x >= this.x1) {
       result = 0;
     } else {
-      result = (-x / (this.x1 - this.x0)) + (this.x1 / (this.x1 - this.x0));
+      // Handle case where x0 = x1 (vertical reverse grade)
+      if (this.x1 === this.x0) {
+        result = 0;
+      } else {
+        result = (-x / (this.x1 - this.x0)) + (this.x1 / (this.x1 - this.x0));
+      }
     }
     return result;
   }

package/lib/curve/sigmoid.js

@@ -9,20 +9,26 @@
 class Sigmoid {
   /**
    * Create a Sigmoid Function.
-   * @param {number} treshhold
-   * @param {number} slope
+   * @param {number} center - The center point of the sigmoid curve (where it outputs 0.5)
+   * @param {number} slope - The slope of the sigmoid curve (higher = steeper transition)
    */
-  constructor(treshold=0, slope=1) {
-    this.t = -treshold;
-    this.s = slope;
+  constructor(center=0, slope=1) {
+    this.center = center;
+    this.slope = slope;
   }
   /**
    * Fuzzify
-   * @param {number} - Point on X axis
+   * @param {number} x - Point on X axis
    * @return {number} fuzzy output 0..1
    */
   fuzzify(x) {
-    return 1.0 / (1.0 + Math.exp((-x-this.t)/this.s));
+    if (this.slope === 0) {
+      // When slope is 0, sigmoid becomes a step function
+      if (x < this.center) return 0;
+      if (x > this.center) return 1;
+      return 0.5; // At center point
+    }
+    return 1.0 / (1.0 + Math.exp(-(x - this.center) / this.slope));
   }
 }
 module.exports = Sigmoid;

package/lib/curve/trapezoid.js

@@ -15,6 +15,19 @@ class Trapezoid extends Shape {
     let result = 0;
     const x = val;
 
+    // Special case: all points equal (spike at single point)
+    if (this.x0 === this.x1 && this.x1 === this.x2 && this.x2 === this.x3) {
+      return x === this.x0 ? 1 : 0;
+    }
+
+    // Special case: x0=x1 and x2=x3 (rectangle)
+    if (this.x0 === this.x1 && this.x2 === this.x3) {
+      if (x < this.x0) return 0;
+      if (x >= this.x0 && x <= this.x2) return 1;
+      if (x > this.x2) return 0;
+      return 0;
+    }
+
     if (x <= this.x0) {
       result = 0;
     } else if (x >= this.x3) {
@@ -22,9 +35,19 @@ class Trapezoid extends Shape {
     } else if ((x >= this.x1) && (x <= this.x2)) {
       result = 1;
     } else if ((x > this.x0) && (x < this.x1)) {
-      result = (x / (this.x1 - this.x0)) - (this.x0 / (this.x1 - this.x0));
+      // Handle case where x0 = x1 (vertical left edge)
+      if (this.x1 === this.x0) {
+        result = 1;
+      } else {
+        result = (x / (this.x1 - this.x0)) - (this.x0 / (this.x1 - this.x0));
+      }
     } else {
-      result = (-x / (this.x3 - this.x2)) + (this.x3 / (this.x3 - this.x2));
+      // Handle case where x2 = x3 (vertical right edge)
+      if (this.x3 === this.x2) {
+        result = 1;
+      } else {
+        result = (-x / (this.x3 - this.x2)) + (this.x3 / (this.x3 - this.x2));
+      }
     }
     return result;
   }

package/lib/curve/triangle.js

@@ -13,6 +13,33 @@ class Triangle extends Shape {
    */
   fuzzify(x) {
     let result = 0;
+    
+    // Special case: all points equal (spike at single point)
+    if (this.x0 === this.x1 && this.x1 === this.x2) {
+      return x === this.x0 ? 1 : 0;
+    }
+    
+    // Special case: x0 = x1 (vertical left edge)
+    if (this.x0 === this.x1) {
+      if (x < this.x0) return 0;
+      if (x === this.x0) return 1;
+      if (x >= this.x2) return 0;
+      if (x < this.x2) {
+        return (this.x2 - x) / (this.x2 - this.x1);
+      }
+    }
+    
+    // Special case: x1 = x2 (vertical right edge)
+    if (this.x1 === this.x2) {
+      if (x <= this.x0) return 0;
+      if (x > this.x0 && x < this.x1) {
+        return (x - this.x0) / (this.x1 - this.x0);
+      }
+      if (x === this.x1) return 1;
+      if (x > this.x1) return 0;
+    }
+    
+    // Normal triangle
     if (x <= this.x0) {
       result = 0;
     } else if (x >= this.x2) {

package/lib/logic.js

@@ -112,8 +112,6 @@ class Logic {
       }
     });
 
-
-
     var namePrefix = '';
     if (!!as && typeof as === 'string') {
       namePrefix = as + '.';

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "es6-fuzz",
   "description": "fuzzy logic with and for es6",
-  "version": "4.0.0",
+  "version": "5.0.0",
   "main": "lib/logic.js",
   "repository": "git@github.com:sebs/es6-fuzz.git",
   "homepage": "https://github.com/sebs/es6-fuzz",
   "scripts": {
     "changelog": "rm ./docs/CHANGELOG.md && npx changelog https://github.com/sebs/es6-fuzz all > ./docs/CHANGELOG.md && git add . && git commit . -m '(churn): changelog'",
-    "test": "npx mocha",
-    "test:watch": "npm test -- -w",
+    "test": "node --test",
+    "test:watch": "node --test --watch",
     "addpush": "git add . && git commit . -m 'docs'",
     "pages": "node ./scripts/publish-gh.js",
     "docs": "jsdoc -c ./jsdoc.json -t ./node_modules/ink-docstrap/template -R ./Readme.md -u ./docs",
@@ -25,11 +25,11 @@
   "author": "Sebastian Schürmann",
   "license": "MIT",
   "devDependencies": {
-    "gh-pages": "4.0.0",
+    "gh-pages": "6.3.0",
     "ink-docstrap": "1.3.2",
-    "jsdoc": "3.6.10"
+    "jsdoc": "4.0.4"
   },
   "dependencies": {
-    "boon-js": "2.0.3"
+    "boon-js": "2.0.5"
   }
 }

package/test/bug-74-test.js

@@ -0,0 +1,100 @@
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Logic = require('../lib/logic');
+const Triangle = require('../lib/curve/triangle');
+const Trapezoid = require('../lib/curve/trapezoid');
+const Grade = require('../lib/curve/grade');
+const getEvaluator = require('boon-js').getEvaluator;
+
+const assess = (likelihood, impact) => {
+    var logicLikelihood = new Logic();
+    const lowLikelihood = new Trapezoid(0, 0, 2, 3);
+    const moderateLikelihood = new Trapezoid(2, 3, 7, 8);
+    const highLikelihood = new Trapezoid(7, 8, 10, 10);
+  
+    logicLikelihood.init('low', lowLikelihood)
+    logicLikelihood.or('moderate', moderateLikelihood)
+    logicLikelihood.or('high', highLikelihood);
+  
+    var logicImpact = new Logic();
+    const publicImpact = new Trapezoid(0, 0, 1.5, 2.5);
+    const internalImpact = new Trapezoid(1.5, 2.5, 4.5, 5.5);
+    const confidentialImpact = new Trapezoid(4.5, 5.5, 7.5, 8.5);
+    const restrictedImpact = new Trapezoid(7.5, 8.5, 10, 10);
+  
+    logicImpact.init('public', publicImpact)
+    logicImpact.or('internal', internalImpact)
+    logicImpact.or('confidential', confidentialImpact);
+    logicImpact.or('restricted', restrictedImpact);
+  
+    const tests = [];
+      // assessment very low
+    const securityTest_low_public = getEvaluator('likelihood.low AND impact.public');
+    tests.push(securityTest_low_public);
+      // assessment low
+    const securityTest_low_internal = getEvaluator('likelihood.low AND impact.internal');
+    tests.push(securityTest_low_internal);
+      // assessment medium
+    const securityTest_low_confidential = getEvaluator('likelihood.low AND impact.confidential');
+    tests.push(securityTest_low_confidential);
+      // assessment high
+    const securityTest_low_restricted = getEvaluator('likelihood.low AND impact.restricted');
+    tests.push(securityTest_low_restricted);
+      // assessment low
+    const securityTest_moderate_public = getEvaluator('likelihood.moderate AND impact.public');
+    tests.push(securityTest_moderate_public);
+      // assessment medium
+    const securityTest_moderate_internal = getEvaluator('likelihood.moderate AND impact.internal');
+    tests.push(securityTest_moderate_internal);
+      // assessment high
+    const securityTest_moderate_confidential = getEvaluator('likelihood.moderate AND impact.confidential');
+    tests.push(securityTest_moderate_confidential);
+      // assessment very high
+    const securityTest_moderate_restricted = getEvaluator('likelihood.moderate AND impact.restricted');
+    tests.push(securityTest_moderate_restricted);
+      // assessment low
+    const securityTest_high_public = getEvaluator('likelihood.high AND impact.public');
+    tests.push(securityTest_high_public);
+      // assessment medium
+    const securityTest_high_internal = getEvaluator('likelihood.high AND impact.internal');
+    tests.push(securityTest_high_internal);
+      // assessment high
+    const securityTest_high_confidential = getEvaluator('likelihood.high AND impact.confidential');
+    tests.push(securityTest_high_confidential);
+      // assessment very high
+    const securityTest_high_restricted = getEvaluator('likelihood.high AND impact.restricted');
+    tests.push(securityTest_high_restricted);
+  
+    const resLikelihood = logicLikelihood.defuzzify(likelihood, 'likelihood');
+    const resImpact = logicImpact.defuzzify(impact, 'impact');
+  
+    const jsBoonInput = { ...resLikelihood.boonJsInputs, ...resImpact.boonJsInputs }
+  
+    const results = [];
+    for(let i = 0; i < tests.length; i++){
+      results.push( tests[i](jsBoonInput) );
+    }
+  
+    if(results[0]) return "very low";
+    else if(results[1]) return "low";
+    else if(results[2]) return "medium";
+    else if(results[3]) return "high";
+    else if(results[4]) return "low";
+    else if(results[5]) return "medium";
+    else if(results[6]) return "high";
+    else if(results[7]) return "high";
+    else if(results[8]) return "low";
+    else if(results[9]) return "medium";
+    else if(results[10]) return "high";
+    else if(results[11]) return "very high";
+    else return "Unknown";
+  }
+
+
+describe('Bug #74 Wrong evaluation at limit of trapezoid', function() {
+    it.skip('asses', ()=>{
+        const restrictedImpact = new Trapezoid(7.5, 8.5, 10, 10);
+        var res = restrictedImpact.fuzzify(10);
+        assert.equal(res, 1);
+    })
+});

package/test/curve/constant.js

@@ -0,0 +1,15 @@
+const { describe, it } = require('node:test');
+const Constant= require('../../lib/curve/constant');
+const assert = require('assert');
+
+describe('Constant', function() {
+  it('is a function', function() {
+    assert.equal(typeof Constant, 'function');
+  });
+  it('same value at 5 and 100', function() {
+    var shape = new Constant(1);
+    var resFive = shape.fuzzify(5);
+    var resHundret = shape.fuzzify(100);
+    assert.equal(resFive, resHundret);
+  });
+});

package/test/{shape-fuzzy-function-test.js → curve/fuzzy-function.js}

@@ -1,5 +1,6 @@
 'use strict';
-const FuzzyFunction= require('../lib/curve/fuzzy-function');
+const { describe, it } = require('node:test');
+const FuzzyFunction= require('../../lib/curve/fuzzy-function');
 const assert = require('assert');
 
 describe('FuzzyFunction', function() {

package/test/{shape-grade-test.js → curve/grade.js}

@@ -1,5 +1,6 @@
 'use strict';
-const Grade = require('../lib/curve/grade');
+const { describe, it } = require('node:test');
+const Grade = require('../../lib/curve/grade');
 const assert = require('assert');
 
 describe('Grade', function() {

package/test/{shape-reverse-grade-test.js → curve/reverse-grade.js}

@@ -1,5 +1,6 @@
 'use strict';
-const ReverseGrade = require('../lib/curve/reverse-grade');
+const { describe, it } = require('node:test');
+const ReverseGrade = require('../../lib/curve/reverse-grade');
 const assert = require('assert');
 
 describe('ReverseGrade', function() {

package/test/{shape-test.js → curve/shape.js}

@@ -1,5 +1,6 @@
 'use strict';
-const Shape = require('../lib/curve/shape');
+const { describe, it } = require('node:test');
+const Shape = require('../../lib/curve/shape');
 const assert = require('assert');
 
 describe('Shape', function() {

package/test/curve/sigmoid.js

@@ -0,0 +1,93 @@
+'use strict';
+const { describe, it } = require('node:test');
+const Sigmoid = require('../../lib/curve/sigmoid');
+const assert = require('assert');
+
+describe('Sigmoid', function() {
+  it('is a function', function() {
+    assert.equal(typeof Sigmoid, 'function');
+  });
+  it('can create a new instance', function() {
+    var sigmoid = new Sigmoid();
+    var res = sigmoid.fuzzify(5);
+    assert.equal(res, 0.9933071490757153);
+  });
+
+  it('0', function() {
+    var sigmoid = new Sigmoid();
+    var res = sigmoid.fuzzify(0);
+    assert.equal(res, 0.5);
+  });
+
+  it('uses treshold', function() {
+    var sigmoid = new Sigmoid(1);
+    var res = sigmoid.fuzzify(1);
+    assert.equal(res, 0.5);
+  });
+
+  describe('slope', function() {
+    it('slope makes actually a difference', function() {
+      const fvalue = 10;
+      var sigmoid = new Sigmoid(0, 10);
+      var resSmall = sigmoid.fuzzify(fvalue);
+      var sigmoid2 = new Sigmoid(0, 100000);
+      var resBig = sigmoid2.fuzzify(fvalue);
+      assert.notEqual(resSmall, resBig);
+    });
+  });
+
+  describe('center parameter behavior', function() {
+    it('should correctly handle positive center values', function() {
+      // This test verifies that the sigmoid is properly centered
+      var sigmoid = new Sigmoid(2, 1);
+      
+      // With center=2, the sigmoid is centered at x=2
+      // So sigmoid.fuzzify(2) should return 0.5
+      var res = sigmoid.fuzzify(2);
+      assert.equal(res, 0.5);
+      
+      // Values to the right of the center should approach 1
+      var rightOfCenter = sigmoid.fuzzify(4);
+      assert(rightOfCenter > 0.5);
+      assert(rightOfCenter < 1);
+      
+      // Values to the left of the center should approach 0
+      var leftOfCenter = sigmoid.fuzzify(0);
+      assert(leftOfCenter < 0.5);
+      assert(leftOfCenter > 0);
+    });
+
+    it('should correctly handle negative center values', function() {
+      var sigmoid = new Sigmoid(-3, 1);
+      
+      // With center=-3, the sigmoid is centered at x=-3
+      // So sigmoid.fuzzify(-3) should return 0.5
+      var res = sigmoid.fuzzify(-3);
+      assert.equal(res, 0.5);
+    });
+
+    it('sigmoid should be 0.075 at zero', function() {
+      // Test that verifies the sigmoid value at x=0 when center=5
+      var sigmoid = new Sigmoid(5, 2);
+      var atZero = sigmoid.fuzzify(0);
+      assert.equal(atZero, 0.07585818002124355);
+    });
+
+    it('verifies sigmoid symmetry', function() {
+      // Test that verifies the sigmoid curve is symmetric around its center
+      var sigmoid = new Sigmoid(5, 2);
+      
+      // Test symmetry around the center point
+      var atCenter = sigmoid.fuzzify(5);
+      assert.equal(atCenter, 0.5);
+      
+      // Test points equidistant from center
+      var rightPoint = sigmoid.fuzzify(7); // 2 units right of center
+      var leftPoint = sigmoid.fuzzify(3);  // 2 units left of center
+      
+      // Due to sigmoid symmetry: f(center+d) + f(center-d) should equal 1
+      var sum = rightPoint + leftPoint;
+      assert(Math.abs(sum - 1) < 0.0000001, `Sum ${sum} should be approximately 1`);
+    });
+  });
+});

package/test/curve/trapezoid.js

@@ -0,0 +1,71 @@
+'use strict';
+const { describe, it } = require('node:test');
+const Trapezoid = require('../../lib/curve/trapezoid');
+const assert = require('assert');
+
+describe('Trapezoid', function() {
+  it('is a function', function() {
+    assert.equal(typeof Trapezoid, 'function');
+  });
+  it('can create a new instance', function() {
+    var trapez = new Trapezoid(0, 10, 20);
+    assert.equal(trapez.x0, 0);
+    assert.equal(trapez.x1, 10);
+    assert.equal(trapez.x2, 20);
+  });
+  it('fuzzify', function() {
+    var trapez = new Trapezoid(20, 30, 90);
+    var res = trapez.fuzzify(25);
+    assert.equal(res, 0.5);
+  });
+  it('avoid NaN if going over max', function() {
+    var trapez = new Trapezoid(20, 30, 90, 100);
+    var res = trapez.fuzzify(99);
+    assert.equal(res, 0.09999999999999964);
+  });
+
+  it('edge case triangle', function() {
+    var trapez = new Trapezoid(0, 0, 1.5, 2.5);
+    var res = trapez.fuzzify(0);
+    assert.equal(res, 0);
+  });
+
+  it('edge case triangle right bounds', function() {
+    var trapez = new Trapezoid(0, 0, 1.5, 2.5);
+    var res = trapez.fuzzify(2.5);
+    assert.equal(res, 0);
+  });
+  
+  it('edge case triangle right top', function() {
+    var trapez = new Trapezoid(0, 0, 1.5, 2.5);
+    var res = trapez.fuzzify(1.5);
+    assert.equal(res, 1);
+  });
+  
+
+  describe('bounds', ()=>{
+    it('trapezoid left bounds 0', function() {
+      var trapez = new Trapezoid(20, 30, 90, 100);
+      var res = trapez.fuzzify(20);
+      assert.equal(res, 0);
+    });
+  
+    it('trapezoid right bounds 0', function() {
+      var trapez = new Trapezoid(20, 30, 90, 100);
+      var res = trapez.fuzzify(100);
+      assert.equal(res, 0);
+    });
+    
+    it('trapezoid left top = 1', function() {
+      var trapez = new Trapezoid(20, 30, 90, 100);
+      var res = trapez.fuzzify(30);
+      assert.equal(res, 1);
+    });
+    
+    it('trapezoid right top = 1', function() {
+      var trapez = new Trapezoid(20, 30, 90, 100);
+      var res = trapez.fuzzify(90);
+      assert.equal(res, 1);
+    });
+  });
+});

package/test/{shape-triangle-test.js → curve/triangle.js}

@@ -1,5 +1,6 @@
 'use strict';
-const Triangle = require('../lib/curve/triangle');
+const { describe, it } = require('node:test');
+const Triangle = require('../../lib/curve/triangle');
 const assert = require('assert');
 
 describe('Triangle', function() {