es6-fuzz 4.0.1 → 5.0.1

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
 
@@ -115,7 +114,7 @@ monsterBiteTest(jsBoonInput)
 
 ## development
 
-**Tests** use mocha and a plugin for traceur
+**Tests** use node internal testing framework
 
 ```
 npm test

package/docs/CHANGELOG.md

@@ -1,9 +1,38 @@
+2025-06-26
+==========
+
+  * 5.0.1
+  * refactor: cleanup of test files
+  * chore: remove unused test
+  * docs: add correct name of test framework
+  * (churn): changelog
+  * 5.0.0
+  * 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
-  * (churn): changelog
   * 4.0.0
   * feature: make the api work with boonJsInputs
   * feature: add a test for outoput names only to consist of alphabet
@@ -131,22 +160,3 @@
   * Changelog
   * Added changelog link
   * 2.6.1
-  * Docs
-  * 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

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.1",
+  "version": "5.0.1",
   "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/*.test.js ./test/**/*.test.js ./test/curve/**/*.test.js",
+    "test:watch": "node --test --watch ./test/*.test.js ./test/**/*.test.js ./test/curve/**/*.test.js",
     "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/curve/constant.test.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.test.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.test.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() {
@@ -7,8 +8,15 @@ describe('Grade', function() {
     assert.equal(typeof Grade, 'function');
   });
   it('can create a new instance', function() {
+    var grade = new Grade(0, 1);
+    assert.ok(grade instanceof Grade);
+  });
+  it('sets x0 property correctly', function() {
     var grade = new Grade(0, 1);
     assert.equal(grade.x0, 0);
+  });
+  it('sets x1 property correctly', function() {
+    var grade = new Grade(0, 1);
     assert.equal(grade.x1, 1);
   });
   it('fuzzify', function() {

package/test/{shape-reverse-grade-test.js → curve/reverse-grade.test.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() {
@@ -7,8 +8,15 @@ describe('ReverseGrade', function() {
     assert.equal(typeof ReverseGrade, 'function');
   });
   it('can create a new instance', function() {
+    var reverseGrade = new ReverseGrade(0, 1);
+    assert.ok(reverseGrade instanceof ReverseGrade);
+  });
+  it('sets x0 property correctly', function() {
     var reverseGrade = new ReverseGrade(0, 1);
     assert.equal(reverseGrade.x0, 0);
+  });
+  it('sets x1 property correctly', function() {
+    var reverseGrade = new ReverseGrade(0, 1);
     assert.equal(reverseGrade.x1, 1);
   });
   it('fuzzify', function() {

package/test/curve/shape.test.js

@@ -0,0 +1,30 @@
+'use strict';
+const { describe, it } = require('node:test');
+const Shape = require('../../lib/curve/shape');
+const assert = require('assert');
+
+describe('Shape', function() {
+  it('is a function', function() {
+    assert.equal(typeof Shape, 'function');
+  });
+  it('can create a new instance', function() {
+    var shape = new Shape(0, 1, 2, 3);
+    assert.ok(shape instanceof Shape);
+  });
+  it('sets x0 property correctly', function() {
+    var shape = new Shape(0, 1, 2, 3);
+    assert.equal(shape.x0, 0);
+  });
+  it('sets x1 property correctly', function() {
+    var shape = new Shape(0, 1, 2, 3);
+    assert.equal(shape.x1, 1);
+  });
+  it('sets x2 property correctly', function() {
+    var shape = new Shape(0, 1, 2, 3);
+    assert.equal(shape.x2, 2);
+  });
+  it('sets x3 property correctly', function() {
+    var shape = new Shape(0, 1, 2, 3);
+    assert.equal(shape.x3, 3);
+  });
+});

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

@@ -1,5 +1,6 @@
 'use strict';
-const Sigmoid = require('../lib/curve/sigmoid');
+const { describe, it } = require('node:test');
+const Sigmoid = require('../../../lib/curve/sigmoid');
 const assert = require('assert');
 
 describe('Sigmoid', function() {
@@ -23,15 +24,4 @@ describe('Sigmoid', function() {
     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);
-    });
-  });
-});
+});

package/test/curve/sigmoid/sigmoid-center-behavior.test.js

@@ -0,0 +1,66 @@
+'use strict';
+const { describe, it } = require('node:test');
+const Sigmoid = require('../../../lib/curve/sigmoid');
+const assert = require('assert');
+
+describe('center parameter behavior', function() {
+  it('should return 0.5 at the center for positive center values', function() {
+    var sigmoid = new Sigmoid(2, 1);
+    var res = sigmoid.fuzzify(2);
+    assert.equal(res, 0.5);
+  });
+
+  it('should return value greater than 0.5 for values right of positive center', function() {
+    var sigmoid = new Sigmoid(2, 1);
+    var rightOfCenter = sigmoid.fuzzify(4);
+    assert(rightOfCenter > 0.5);
+  });
+
+  it('should return value less than 1 for values right of positive center', function() {
+    var sigmoid = new Sigmoid(2, 1);
+    var rightOfCenter = sigmoid.fuzzify(4);
+    assert(rightOfCenter < 1);
+  });
+
+  it('should return value less than 0.5 for values left of positive center', function() {
+    var sigmoid = new Sigmoid(2, 1);
+    var leftOfCenter = sigmoid.fuzzify(0);
+    assert(leftOfCenter < 0.5);
+  });
+
+  it('should return value greater than 0 for values left of positive center', function() {
+    var sigmoid = new Sigmoid(2, 1);
+    var leftOfCenter = sigmoid.fuzzify(0);
+    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('should return 0.5 at center point for symmetry', function() {
+    var sigmoid = new Sigmoid(5, 2);
+    var atCenter = sigmoid.fuzzify(5);
+    assert.equal(atCenter, 0.5);
+  });
+
+  it('should be symmetric around center point', function() {
+    var sigmoid = new Sigmoid(5, 2);
+    var rightPoint = sigmoid.fuzzify(7); // 2 units right of center
+    var leftPoint = sigmoid.fuzzify(3);  // 2 units left of center
+    var sum = rightPoint + leftPoint;
+    assert(Math.abs(sum - 1) < 0.0000001, `Sum ${sum} should be approximately 1`);
+  });
+});

package/test/curve/sigmoid/sigmoid-slope.test.js

@@ -0,0 +1,15 @@
+'use strict';
+const { describe, it } = require('node:test');
+const Sigmoid = require('../../../lib/curve/sigmoid');
+const assert = require('assert');
+
+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);
+  });
+});

package/test/curve/trapezoid/trapezoid-basic.test.js

@@ -0,0 +1,54 @@
+'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.ok(trapez instanceof Trapezoid);
+  });
+  it('sets x0 property correctly', function() {
+    var trapez = new Trapezoid(0, 10, 20);
+    assert.equal(trapez.x0, 0);
+  });
+  it('sets x1 property correctly', function() {
+    var trapez = new Trapezoid(0, 10, 20);
+    assert.equal(trapez.x1, 10);
+  });
+  it('sets x2 property correctly', function() {
+    var trapez = new Trapezoid(0, 10, 20);
+    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);
+  });
+});

package/test/curve/trapezoid/trapezoid-bounds.test.js

@@ -0,0 +1,30 @@
+'use strict';
+const { describe, it } = require('node:test');
+const Trapezoid = require('../../../lib/curve/trapezoid');
+const assert = require('assert');
+
+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.test.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() {

package/test/edge-cases/constant-edge-values.test.js

@@ -0,0 +1,56 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Constant = require('../../lib/curve/constant');
+
+describe('Constant edge values', function() {
+  describe('all possible constant values', function() {
+    it('should return 0 for constant value 0', function() {
+      assert.equal(new Constant(0).fuzzify(), 0);
+    });
+    
+    it('should return 0.5 for constant value 0.5', function() {
+      assert.equal(new Constant(0.5).fuzzify(), 0.5);
+    });
+    
+    it('should return 1 for constant value 1', function() {
+      assert.equal(new Constant(1).fuzzify(), 1);
+    });
+    
+    it('should return -1 for constant value -1', function() {
+      assert.equal(new Constant(-1).fuzzify(), -1);
+    });
+    
+    it('should return 2 for constant value 2', function() {
+      assert.equal(new Constant(2).fuzzify(), 2);
+    });
+    
+    it('should return -0.5 for constant value -0.5', function() {
+      assert.equal(new Constant(-0.5).fuzzify(), -0.5);
+    });
+    
+    it('should return 1.5 for constant value 1.5', function() {
+      assert.equal(new Constant(1.5).fuzzify(), 1.5);
+    });
+  });
+
+  describe('ignoring x parameter in fuzzify', function() {
+    const constant = new Constant(0.7);
+    
+    it('should return constant value for x=0', function() {
+      assert.equal(constant.fuzzify(0), 0.7);
+    });
+    
+    it('should return constant value for x=100', function() {
+      assert.equal(constant.fuzzify(100), 0.7);
+    });
+    
+    it('should return constant value for x=-100', function() {
+      assert.equal(constant.fuzzify(-100), 0.7);
+    });
+    
+    it('should return constant value for x=Infinity', function() {
+      assert.equal(constant.fuzzify(Infinity), 0.7);
+    });
+  });
+});