es6-fuzz 4.0.1 → 5.0.1

package/test/edge-cases/fuzzy-function-edge-cases.test.js

@@ -0,0 +1,71 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const FuzzyFunction = require('../../lib/curve/fuzzy-function');
+
+describe('FuzzyFunction edge cases', function() {
+  describe('functions returning values outside [0,1]', function() {
+    describe('function returning > 1 for x > 0.5', function() {
+      const func1 = new FuzzyFunction(x => x * 2);
+      
+      it('should return valid value for x=0.3', function() {
+        assert.equal(func1.fuzzify(0.3), 0.6);
+      });
+      
+      it('should return exactly 1 for x=0.5', function() {
+        assert.equal(func1.fuzzify(0.5), 1);
+      });
+      
+      it('should throw error for x=0.7', function() {
+        assert.throws(() => func1.fuzzify(0.7), /fuzzified result must be smaller than 1/);
+      });
+    });
+    
+    describe('function returning < 0 for x < 1', function() {
+      const func2 = new FuzzyFunction(x => x - 1);
+      
+      it('should throw error for x=0.5', function() {
+        assert.throws(() => func2.fuzzify(0.5), /fuzzified result must be smaller than 1/);
+      });
+      
+      it('should return exactly 0 for x=1', function() {
+        assert.equal(func2.fuzzify(1), 0);
+      });
+      
+      it('should throw error for x=0.8', function() {
+        assert.throws(() => func2.fuzzify(0.8), /fuzzified result must be smaller than 1/);
+      });
+    });
+  });
+
+  describe('complex mathematical functions', function() {
+    const sinFunc = new FuzzyFunction(x => (Math.sin(x) + 1) / 2);
+    
+    it('should return 0.5 for x=0', function() {
+      assert(sinFunc.fuzzify(0) === 0.5);
+    });
+    
+    it('should return 1 for x=PI/2', function() {
+      assert(sinFunc.fuzzify(Math.PI / 2) === 1);
+    });
+    
+    it('should return 0 for x=3*PI/2', function() {
+      assert(sinFunc.fuzzify(3 * Math.PI / 2) === 0);
+    });
+  });
+
+  describe('functions that throw errors', function() {
+    const errorFunc = new FuzzyFunction(x => {
+      if (x < 0) throw new Error('Negative input');
+      return x;
+    });
+    
+    it('should return valid value for x=0.5', function() {
+      assert.equal(errorFunc.fuzzify(0.5), 0.5);
+    });
+    
+    it('should throw error for negative input', function() {
+      assert.throws(() => errorFunc.fuzzify(-1), /Negative input/);
+    });
+  });
+});

package/test/edge-cases/grade-edge-cases.test.js

@@ -0,0 +1,42 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Grade = require('../../lib/curve/grade');
+
+describe('Grade edge cases', function() {
+  describe('vertical grade (x0=x1)', function() {
+    const grade = new Grade(5, 5);
+    
+    it('should return 0 for value before x0', function() {
+      assert.equal(grade.fuzzify(4.9), 0);
+    });
+    
+    it('should return 1 for value at x0=x1', function() {
+      assert.equal(grade.fuzzify(5), 1);
+    });
+    
+    it('should return 1 for value after x1', function() {
+      assert.equal(grade.fuzzify(5.1), 1);
+    });
+    
+    it('should return 1 for very large value', function() {
+      assert.equal(grade.fuzzify(100), 1);
+    });
+  });
+
+  describe('very steep grade', function() {
+    const grade = new Grade(5, 5.0001);
+    
+    it('should return 0 for value before x0', function() {
+      assert.equal(grade.fuzzify(4.9), 0);
+    });
+    
+    it('should return greater than 0.4 for value at midpoint', function() {
+      assert(grade.fuzzify(5.00005) > 0.4);
+    });
+    
+    it('should return 1 for value well after x1', function() {
+      assert.equal(grade.fuzzify(5.1), 1);
+    });
+  });
+});

package/test/edge-cases/reverse-grade-edge-cases.test.js

@@ -0,0 +1,42 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const ReverseGrade = require('../../lib/curve/reverse-grade');
+
+describe('ReverseGrade edge cases', function() {
+  describe('vertical reverse grade (x0=x1)', function() {
+    const reverseGrade = new ReverseGrade(5, 5);
+    
+    it('should return 1 for value before x0', function() {
+      assert.equal(reverseGrade.fuzzify(4.9), 1);
+    });
+    
+    it('should return 1 for value at x0=x1', function() {
+      assert.equal(reverseGrade.fuzzify(5), 1);
+    });
+    
+    it('should return 0 for value after x1', function() {
+      assert.equal(reverseGrade.fuzzify(5.1), 0);
+    });
+    
+    it('should return 0 for very large value', function() {
+      assert.equal(reverseGrade.fuzzify(100), 0);
+    });
+  });
+
+  describe('very steep reverse grade', function() {
+    const reverseGrade = new ReverseGrade(5, 5.0001);
+    
+    it('should return 1 for value before x0', function() {
+      assert.equal(reverseGrade.fuzzify(4.9), 1);
+    });
+    
+    it('should return less than 0.6 for value at midpoint', function() {
+      assert(reverseGrade.fuzzify(5.00005) < 0.6);
+    });
+    
+    it('should return 0 for value well after x1', function() {
+      assert.equal(reverseGrade.fuzzify(5.1), 0);
+    });
+  });
+});

package/test/edge-cases/shapes-large-values.test.js

@@ -0,0 +1,78 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Triangle = require('../../lib/curve/triangle');
+const Trapezoid = require('../../lib/curve/trapezoid');
+const Grade = require('../../lib/curve/grade');
+const ReverseGrade = require('../../lib/curve/reverse-grade');
+const Sigmoid = require('../../lib/curve/sigmoid');
+
+describe('Shapes with very large x values', function() {
+  describe('Infinity handling', function() {
+    const triangle = new Triangle(0, 10, 20);
+    const trapezoid = new Trapezoid(0, 10, 20, 30);
+    const grade = new Grade(0, 10);
+    const reverseGrade = new ReverseGrade(0, 10);
+    const sigmoid = new Sigmoid(10, 1);
+    
+    it('should return 0 for triangle with positive Infinity', function() {
+      assert.equal(triangle.fuzzify(Infinity), 0);
+    });
+    
+    it('should return 0 for triangle with negative Infinity', function() {
+      assert.equal(triangle.fuzzify(-Infinity), 0);
+    });
+    
+    it('should return 0 for trapezoid with positive Infinity', function() {
+      assert.equal(trapezoid.fuzzify(Infinity), 0);
+    });
+    
+    it('should return 0 for trapezoid with negative Infinity', function() {
+      assert.equal(trapezoid.fuzzify(-Infinity), 0);
+    });
+    
+    it('should return 1 for grade with positive Infinity', function() {
+      assert.equal(grade.fuzzify(Infinity), 1);
+    });
+    
+    it('should return 0 for grade with negative Infinity', function() {
+      assert.equal(grade.fuzzify(-Infinity), 0);
+    });
+    
+    it('should return 0 for reverseGrade with positive Infinity', function() {
+      assert.equal(reverseGrade.fuzzify(Infinity), 0);
+    });
+    
+    it('should return 1 for reverseGrade with negative Infinity', function() {
+      assert.equal(reverseGrade.fuzzify(-Infinity), 1);
+    });
+    
+    it('should return 1 for sigmoid with positive Infinity', function() {
+      assert.equal(sigmoid.fuzzify(Infinity), 1);
+    });
+    
+    it('should return 0 for sigmoid with negative Infinity', function() {
+      assert.equal(sigmoid.fuzzify(-Infinity), 0);
+    });
+  });
+
+  describe('very large numbers', function() {
+    const triangle = new Triangle(0, 1e10, 2e10);
+    
+    it('should return 0 for value at x0', function() {
+      assert.equal(triangle.fuzzify(0), 0);
+    });
+    
+    it('should return 1 for value at x1', function() {
+      assert.equal(triangle.fuzzify(1e10), 1);
+    });
+    
+    it('should return 0 for value at x2', function() {
+      assert.equal(triangle.fuzzify(2e10), 0);
+    });
+    
+    it('should return 0.5 for value at midpoint', function() {
+      assert.equal(triangle.fuzzify(1.5e10), 0.5);
+    });
+  });
+});

package/test/edge-cases/shapes-negative-values.test.js

@@ -0,0 +1,75 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Triangle = require('../../lib/curve/triangle');
+const Trapezoid = require('../../lib/curve/trapezoid');
+
+describe('Shapes with negative x values', function() {
+  describe('triangle with negative x values', function() {
+    const triangle = new Triangle(-10, -5, 0);
+    
+    it('should return 0 for value far before x0', function() {
+      assert.equal(triangle.fuzzify(-15), 0);
+    });
+    
+    it('should return 0 for value at x0', function() {
+      assert.equal(triangle.fuzzify(-10), 0);
+    });
+    
+    it('should return 0.5 for value at midpoint of left slope', function() {
+      assert.equal(triangle.fuzzify(-7.5), 0.5);
+    });
+    
+    it('should return 1 for value at x1', function() {
+      assert.equal(triangle.fuzzify(-5), 1);
+    });
+    
+    it('should return 0.5 for value at midpoint of right slope', function() {
+      assert.equal(triangle.fuzzify(-2.5), 0.5);
+    });
+    
+    it('should return 0 for value at x2', function() {
+      assert.equal(triangle.fuzzify(0), 0);
+    });
+    
+    it('should return 0 for value after x2', function() {
+      assert.equal(triangle.fuzzify(5), 0);
+    });
+  });
+
+  describe('trapezoid with negative x values', function() {
+    const trapezoid = new Trapezoid(-20, -15, -5, 0);
+    
+    it('should return 0 for value before x0', function() {
+      assert.equal(trapezoid.fuzzify(-25), 0);
+    });
+    
+    it('should return 0 for value at x0', function() {
+      assert.equal(trapezoid.fuzzify(-20), 0);
+    });
+    
+    it('should return 0.5 for value at midpoint of left slope', function() {
+      assert.equal(trapezoid.fuzzify(-17.5), 0.5);
+    });
+    
+    it('should return 1 for value at x1', function() {
+      assert.equal(trapezoid.fuzzify(-15), 1);
+    });
+    
+    it('should return 1 for value in middle plateau', function() {
+      assert.equal(trapezoid.fuzzify(-10), 1);
+    });
+    
+    it('should return 1 for value at x2', function() {
+      assert.equal(trapezoid.fuzzify(-5), 1);
+    });
+    
+    it('should return 0.5 for value at midpoint of right slope', function() {
+      assert.equal(trapezoid.fuzzify(-2.5), 0.5);
+    });
+    
+    it('should return 0 for value at x3', function() {
+      assert.equal(trapezoid.fuzzify(0), 0);
+    });
+  });
+});

package/test/edge-cases/sigmoid-edge-cases.test.js

@@ -0,0 +1,70 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Sigmoid = require('../../lib/curve/sigmoid');
+
+describe('Sigmoid edge cases', function() {
+  describe('zero slope (becomes step function)', function() {
+    const sigmoid = new Sigmoid(5, 0);
+    
+    it('should return 0 for value before center', function() {
+      assert.equal(sigmoid.fuzzify(4.9), 0);
+    });
+    
+    it('should return 0.5 for value at center', function() {
+      assert.equal(sigmoid.fuzzify(5), 0.5);
+    });
+    
+    it('should return 1 for value after center', function() {
+      assert.equal(sigmoid.fuzzify(5.1), 1);
+    });
+  });
+
+  describe('very small slope (near step function)', function() {
+    const sigmoid = new Sigmoid(5, 0.0001);
+    
+    it('should return near 0 for value slightly before center', function() {
+      assert(sigmoid.fuzzify(4.99) < 0.01);
+    });
+    
+    it('should return 0.5 for value at center', function() {
+      assert(sigmoid.fuzzify(5) === 0.5);
+    });
+    
+    it('should return near 1 for value slightly after center', function() {
+      assert(sigmoid.fuzzify(5.01) > 0.99);
+    });
+  });
+
+  describe('very large slope (near constant 0.5)', function() {
+    const sigmoid = new Sigmoid(5, 10000);
+    
+    it('should return approximately 0.5 for value far left', function() {
+      assert(Math.abs(sigmoid.fuzzify(0) - 0.5) < 0.1);
+    });
+    
+    it('should return 0.5 for value at center', function() {
+      assert(sigmoid.fuzzify(5) === 0.5);
+    });
+    
+    it('should return approximately 0.5 for value far right', function() {
+      assert(Math.abs(sigmoid.fuzzify(10) - 0.5) < 0.1);
+    });
+  });
+
+  describe('negative slope', function() {
+    const sigmoid = new Sigmoid(5, -1);
+    
+    it('should return greater than 0.5 for value before center', function() {
+      assert(sigmoid.fuzzify(3) > 0.5);
+    });
+    
+    it('should return 0.5 for value at center', function() {
+      assert(sigmoid.fuzzify(5) === 0.5);
+    });
+    
+    it('should return less than 0.5 for value after center', function() {
+      assert(sigmoid.fuzzify(7) < 0.5);
+    });
+  });
+});

package/test/edge-cases/trapezoid-special-cases.test.js

@@ -0,0 +1,94 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Trapezoid = require('../../lib/curve/trapezoid');
+
+describe('Trapezoid special cases', function() {
+  describe('square trapezoid (x1=x2)', function() {
+    const trapezoid = new Trapezoid(0, 5, 5, 10);
+    
+    it('should return 0 for value before x0', function() {
+      assert.equal(trapezoid.fuzzify(-1), 0);
+    });
+    
+    it('should return 0 for value at x0', function() {
+      assert.equal(trapezoid.fuzzify(0), 0);
+    });
+    
+    it('should return 0.5 for value at midpoint of left slope', function() {
+      assert.equal(trapezoid.fuzzify(2.5), 0.5);
+    });
+    
+    it('should return 1 for value at x1=x2', function() {
+      assert.equal(trapezoid.fuzzify(5), 1);
+    });
+    
+    it('should return 0.5 for value at midpoint of right slope', function() {
+      assert.equal(trapezoid.fuzzify(7.5), 0.5);
+    });
+    
+    it('should return 0 for value at x3', function() {
+      assert.equal(trapezoid.fuzzify(10), 0);
+    });
+    
+    it('should return 0 for value after x3', function() {
+      assert.equal(trapezoid.fuzzify(11), 0);
+    });
+  });
+
+  describe('degenerate trapezoid (x0=x1 and x2=x3)', function() {
+    const trapezoid = new Trapezoid(5, 5, 10, 10);
+    
+    it('should return 0 for value before x0', function() {
+      assert.equal(trapezoid.fuzzify(4.9), 0);
+    });
+    
+    it('should return 1 for value at x0=x1', function() {
+      assert.equal(trapezoid.fuzzify(5), 1);
+    });
+    
+    it('should return 1 for value in middle', function() {
+      assert.equal(trapezoid.fuzzify(7.5), 1);
+    });
+    
+    it('should return 1 for value at x2=x3', function() {
+      assert.equal(trapezoid.fuzzify(10), 1);
+    });
+    
+    it('should return 0 for value after x3', function() {
+      assert.equal(trapezoid.fuzzify(10.1), 0);
+    });
+  });
+
+  describe('very narrow trapezoid (x1 and x2 very close)', function() {
+    const trapezoid = new Trapezoid(0, 4.999, 5.001, 10);
+    
+    it('should return 1 for value at center', function() {
+      assert.equal(trapezoid.fuzzify(5), 1);
+    });
+    
+    it('should return approximately 1 for value at x1', function() {
+      assert(Math.abs(trapezoid.fuzzify(4.999) - 1) < 0.01);
+    });
+    
+    it('should return approximately 1 for value at x2', function() {
+      assert(Math.abs(trapezoid.fuzzify(5.001) - 1) < 0.01);
+    });
+  });
+
+  describe('all points equal (degenerate to point)', function() {
+    const trapezoid = new Trapezoid(5, 5, 5, 5);
+    
+    it('should return 0 for value before the point', function() {
+      assert.equal(trapezoid.fuzzify(4.9), 0);
+    });
+    
+    it('should return 1 for value at the point', function() {
+      assert.equal(trapezoid.fuzzify(5), 1);
+    });
+    
+    it('should return 0 for value after the point', function() {
+      assert.equal(trapezoid.fuzzify(5.1), 0);
+    });
+  });
+});

package/test/edge-cases/triangle-degenerate-cases.test.js

@@ -0,0 +1,62 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Triangle = require('../../lib/curve/triangle');
+
+describe('Triangle degenerate cases', function() {
+  describe('triangle with all points equal (x0=x1=x2)', function() {
+    const triangle = new Triangle(5, 5, 5);
+    
+    it('should return 0 for value before the point', function() {
+      assert.equal(triangle.fuzzify(4.9), 0);
+    });
+    
+    it('should return 1 for value at the point', function() {
+      assert.equal(triangle.fuzzify(5), 1);
+    });
+    
+    it('should return 0 for value after the point', function() {
+      assert.equal(triangle.fuzzify(5.1), 0);
+    });
+  });
+
+  describe('triangle with x0=x1 (right angle left)', function() {
+    const triangle = new Triangle(5, 5, 10);
+    
+    it('should return 0 for value before x0', function() {
+      assert.equal(triangle.fuzzify(4.9), 0);
+    });
+    
+    it('should return 1 for value at x0=x1', function() {
+      assert.equal(triangle.fuzzify(5), 1);
+    });
+    
+    it('should return 0.5 for value at midpoint', function() {
+      assert.equal(triangle.fuzzify(7.5), 0.5);
+    });
+    
+    it('should return 0 for value at x2', function() {
+      assert.equal(triangle.fuzzify(10), 0);
+    });
+  });
+
+  describe('triangle with x1=x2 (right angle right)', function() {
+    const triangle = new Triangle(0, 5, 5);
+    
+    it('should return 0 for value at x0', function() {
+      assert.equal(triangle.fuzzify(0), 0);
+    });
+    
+    it('should return 0.5 for value at midpoint', function() {
+      assert.equal(triangle.fuzzify(2.5), 0.5);
+    });
+    
+    it('should return 1 for value at x1=x2', function() {
+      assert.equal(triangle.fuzzify(5), 1);
+    });
+    
+    it('should return 0 for value after x2', function() {
+      assert.equal(triangle.fuzzify(5.1), 0);
+    });
+  });
+});

package/test/error-handling/empty-rules-handling.test.js

@@ -0,0 +1,25 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Logic = require('../../lib/logic');
+
+describe('Empty rules array handling', function() {
+  describe('defuzzify with no rules', function() {
+    const logic = new Logic();
+    logic.initCalled = true;
+    logic.rules = [];
+    const result = logic.defuzzify(5);
+    
+    it('should return defuzzified as none', function() {
+      assert.equal(result.defuzzified, 'none');
+    });
+    
+    it('should return fuzzified as 0', function() {
+      assert.equal(result.fuzzified, 0);
+    });
+    
+    it('should return empty rules array', function() {
+      assert.deepEqual(result.rules, []);
+    });
+  });
+});

package/test/error-handling/es6-class-instantiation.test.js

@@ -0,0 +1,52 @@
+'use strict';
+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 ReverseGrade = require('../../lib/curve/reverse-grade');
+const Sigmoid = require('../../lib/curve/sigmoid');
+const Constant = require('../../lib/curve/constant');
+const FuzzyFunction = require('../../lib/curve/fuzzy-function');
+const Shape = require('../../lib/curve/shape');
+
+describe('ES6 class instantiation', function() {
+  describe('shapes without new keyword', function() {
+    it('should throw error when calling Triangle without new', function() {
+      assert.throws(() => Triangle(0, 5, 10), /Class constructor .* cannot be invoked without 'new'/);
+    });
+    
+    it('should throw error when calling Trapezoid without new', function() {
+      assert.throws(() => Trapezoid(0, 5, 10, 15), /Class constructor .* cannot be invoked without 'new'/);
+    });
+    
+    it('should throw error when calling Grade without new', function() {
+      assert.throws(() => Grade(0, 10), /Class constructor .* cannot be invoked without 'new'/);
+    });
+    
+    it('should throw error when calling ReverseGrade without new', function() {
+      assert.throws(() => ReverseGrade(0, 10), /Class constructor .* cannot be invoked without 'new'/);
+    });
+    
+    it('should throw error when calling Sigmoid without new', function() {
+      assert.throws(() => Sigmoid(5, 1), /Class constructor .* cannot be invoked without 'new'/);
+    });
+    
+    it('should throw error when calling Constant without new', function() {
+      assert.throws(() => Constant(0.5), /Class constructor .* cannot be invoked without 'new'/);
+    });
+    
+    it('should throw error when calling Shape without new', function() {
+      assert.throws(() => Shape(0, 5, 10, 15), /Class constructor .* cannot be invoked without 'new'/);
+    });
+    
+    it('should throw error when calling FuzzyFunction without new', function() {
+      assert.throws(() => FuzzyFunction(x => x), /Class constructor .* cannot be invoked without 'new'/);
+    });
+    
+    it('should throw error when calling Logic without new', function() {
+      assert.throws(() => Logic(), /Class constructor .* cannot be invoked without 'new'/);
+    });
+  });
+});

package/test/error-handling/fuzzy-function-validation.test.js

@@ -0,0 +1,66 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const FuzzyFunction = require('../../lib/curve/fuzzy-function');
+
+describe('FuzzyFunction validation', function() {
+  describe('invalid callback types', function() {
+    it('should throw TypeError when callback is string', function() {
+      assert.throws(() => {
+        const func = new FuzzyFunction('not a function');
+        func.fuzzify(5);
+      }, TypeError);
+    });
+
+    it('should throw TypeError when callback is null', function() {
+      assert.throws(() => {
+        const func = new FuzzyFunction(null);
+        func.fuzzify(5);
+      }, TypeError);
+    });
+
+    it('should throw TypeError when callback is undefined', function() {
+      assert.throws(() => {
+        const func = new FuzzyFunction(undefined);
+        func.fuzzify(5);
+      }, TypeError);
+    });
+  });
+
+  describe('callback returns non-number types', function() {
+    it('should throw error when callback returns string', function() {
+      const func = new FuzzyFunction(() => 'string');
+      assert.throws(() => func.fuzzify(5), /fuzzified result must be smaller than 1/);
+    });
+    
+    it('should return null when callback returns null', function() {
+      const func = new FuzzyFunction(() => null);
+      assert.equal(func.fuzzify(5), null);
+    });
+    
+    it('should throw error when callback returns undefined', function() {
+      const func = new FuzzyFunction(() => undefined);
+      assert.throws(() => func.fuzzify(5), /fuzzified result must be smaller than 1/);
+    });
+  });
+
+  describe('callback with conditional returns', function() {
+    const func = new FuzzyFunction(x => {
+      if (x < 0) return -1; // Invalid
+      if (x > 1) return 2; // Invalid
+      return x; // Valid for [0,1]
+    });
+    
+    it('should return valid value for input 0.5', function() {
+      assert.equal(func.fuzzify(0.5), 0.5);
+    });
+    
+    it('should throw error for negative input', function() {
+      assert.throws(() => func.fuzzify(-1), /fuzzified result must be smaller than 1/);
+    });
+    
+    it('should throw error for input greater than 1', function() {
+      assert.throws(() => func.fuzzify(2), /fuzzified result must be smaller than 1/);
+    });
+  });
+});