es6-fuzz 5.0.0 → 5.0.1

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/);
+    });
+  });
+});

package/test/error-handling/invalid-chaining-sequences.test.js

@@ -0,0 +1,40 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Logic = require('../../lib/logic');
+const Triangle = require('../../lib/curve/triangle');
+
+describe('Invalid chaining sequences', function() {
+  describe('multiple init calls', function() {
+    const logic = new Logic();
+    const triangle1 = new Triangle(0, 5, 10);
+    const triangle2 = new Triangle(10, 15, 20);
+    
+    it('should not throw error on second init call', function() {
+      logic.init('cold', triangle1);
+      assert.doesNotThrow(() => logic.init('hot', triangle2));
+    });
+    
+    it('should contain both rules after multiple init calls', function() {
+      assert.equal(logic.rules.length, 2);
+    });
+  });
+
+  describe('chaining after defuzzify', function() {
+    const logic = new Logic();
+    const triangle = new Triangle(0, 5, 10);
+    
+    it('should allow chaining operations after defuzzify', function() {
+      logic.init('cold', triangle).and('warm', new Triangle(5, 10, 15));
+      logic.defuzzify(7.5);
+      
+      // Can continue chaining after defuzzify
+      assert.doesNotThrow(() => logic.or('hot', new Triangle(10, 15, 20)));
+    });
+    
+    it('should have all rules after chaining post-defuzzify', function() {
+      logic.defuzzify(12.5);
+      assert.equal(logic.rules.length, 3);
+    });
+  });
+});

package/test/error-handling/logic-validation.test.js

@@ -0,0 +1,78 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Logic = require('../../lib/logic');
+const Triangle = require('../../lib/curve/triangle');
+
+describe('Logic class validation', function() {
+  describe('method calls without init', function() {
+    it('should throw error when calling defuzzify without init', function() {
+      const logic = new Logic();
+      assert.throws(() => logic.defuzzify(5), /init needs to be called before performing logic/);
+    });
+
+    it('should throw error when calling and() without init', function() {
+      const logic = new Logic();
+      const triangle = new Triangle(0, 5, 10);
+      assert.throws(() => logic.and('hot', triangle), /init needs to be called before performing logic/);
+    });
+
+    it('should throw error when calling or() without init', function() {
+      const logic = new Logic();
+      const triangle = new Triangle(0, 5, 10);
+      assert.throws(() => logic.or('hot', triangle), /init needs to be called before performing logic/);
+    });
+
+    it('should throw error when calling not() without init', function() {
+      const logic = new Logic();
+      const triangle = new Triangle(0, 5, 10);
+      assert.throws(() => logic.not('hot', triangle), /init needs to be called before performing logic/);
+    });
+  });
+
+  describe('invalid output names', function() {
+    const logic = new Logic();
+    const triangle = new Triangle(0, 5, 10);
+    
+    it('should throw error for output name with numbers', function() {
+      assert.throws(() => logic.init('hot123', triangle), /Output names can only be strings without space/);
+    });
+
+    it('should throw error for output name with spaces', function() {
+      assert.throws(() => logic.init('hot cold', triangle), /Output names can only be strings without space/);
+    });
+
+    it('should throw error for output name with hyphen', function() {
+      assert.throws(() => logic.init('hot-cold', triangle), /Output names can only be strings without space/);
+    });
+    
+    it('should throw error for output name with underscore', function() {
+      assert.throws(() => logic.init('hot_cold', triangle), /Output names can only be strings without space/);
+    });
+    
+    it('should throw error for output name with dot', function() {
+      assert.throws(() => logic.init('hot.cold', triangle), /Output names can only be strings without space/);
+    });
+  });
+
+  describe('valid output names', function() {
+    const logic = new Logic();
+    const triangle = new Triangle(0, 5, 10);
+    
+    it('should allow lowercase output name', function() {
+      assert.doesNotThrow(() => logic.init('hot', triangle));
+    });
+    
+    it('should allow title case output name', function() {
+      assert.doesNotThrow(() => logic.init('Hot', triangle));
+    });
+    
+    it('should allow uppercase output name', function() {
+      assert.doesNotThrow(() => logic.init('HOT', triangle));
+    });
+    
+    it('should allow camelCase output name', function() {
+      assert.doesNotThrow(() => logic.init('veryHot', triangle));
+    });
+  });
+});

package/test/error-handling/property-immutability.test.js

@@ -0,0 +1,29 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Triangle = require('../../lib/curve/triangle');
+
+describe('Property immutability', function() {
+  describe('shape properties are read-only', function() {
+    const triangle = new Triangle(0, 5, 10);
+    
+    it('should throw error when attempting to modify x0', function() {
+      assert.throws(() => {
+        'use strict';
+        triangle.x0 = 100;
+      }, /Cannot assign to read only property/);
+    });
+    
+    it('should keep x0 unchanged after modification attempt', function() {
+      assert.equal(triangle.x0, 0);
+    });
+    
+    it('should keep x1 unchanged', function() {
+      assert.equal(triangle.x1, 5);
+    });
+    
+    it('should keep x2 unchanged', function() {
+      assert.equal(triangle.x2, 10);
+    });
+  });
+});

package/test/error-handling/shape-constructor-validation.test.js

@@ -0,0 +1,70 @@
+'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 Sigmoid = require('../../lib/curve/sigmoid');
+
+describe('Shape constructor validation', function() {
+  describe('NaN parameters', function() {
+    it('should return number when Triangle has NaN in x0', function() {
+      const triangle = new Triangle(NaN, 5, 10);
+      const result = triangle.fuzzify(5);
+      assert(typeof result === 'number');
+    });
+    
+    it('should return number when Trapezoid has NaN in x1', function() {
+      const trapezoid = new Trapezoid(0, NaN, 10, 15);
+      const result = trapezoid.fuzzify(5);
+      assert(typeof result === 'number');
+    });
+    
+    it('should return number when Grade has NaN in x0', function() {
+      const grade = new Grade(NaN, 10);
+      const result = grade.fuzzify(5);
+      assert(typeof result === 'number');
+    });
+  });
+
+  describe('Infinity parameters', function() {
+    describe('Triangle with Infinity in x2', function() {
+      const triangle = new Triangle(0, 10, Infinity);
+      
+      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(10), 1);
+      });
+      
+      it('should return NaN for value beyond x1', function() {
+        assert(isNaN(triangle.fuzzify(20)));
+      });
+    });
+    
+    describe('Grade with Infinity in x1', function() {
+      const grade = new Grade(0, Infinity);
+      
+      it('should return 0 for value at x0', function() {
+        assert.equal(grade.fuzzify(0), 0);
+      });
+      
+      it('should return 0 for large finite value', function() {
+        assert.equal(grade.fuzzify(1000), 0);
+      });
+      
+      it('should return 1 for Infinity value', function() {
+        assert.equal(grade.fuzzify(Infinity), 1);
+      });
+    });
+  });
+
+  describe('undefined parameters with defaults', function() {
+    it('should use default parameters for Sigmoid', function() {
+      const sigmoid = new Sigmoid();
+      assert.equal(sigmoid.fuzzify(0), 0.5);
+    });
+  });
+});

package/test/integration/and-or-not-combinations.test.js

@@ -0,0 +1,42 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Logic = require('../../lib/logic');
+
+describe('AND/OR/NOT combinations', function() {
+  it('should correctly implement fuzzy AND logic', function() {
+    const logic = new Logic();
+    
+    const hot = new logic.c.Trapezoid(25, 30, 40, 45);
+    const humid = new logic.c.Trapezoid(60, 70, 80, 90);
+    
+    logic.init('comfortable', hot)
+      .and('uncomfortable', humid);
+    
+    // At 35°C and representing humidity
+    // hot.fuzzify(35) = 1, humid.fuzzify(35) < 0.5
+    // AND takes minimum of lastShape and current
+    const result = logic.defuzzify(35);
+    // Since humid has lower value, uncomfortable wins
+    assert.equal(result.defuzzified, 'uncomfortable');
+  });
+
+  it('should correctly implement fuzzy NOT logic', function() {
+    const logic = new Logic();
+    
+    const cold = new logic.c.Triangle(0, 10, 20);
+    
+    logic.init('cold', cold)
+      .not('notCold', cold);
+    
+    // At 10°C, cold = 1, NOT cold = 0
+    // But the logic compares with lastShape, so notCold wins when NOT result differs
+    const result = logic.defuzzify(10);
+    assert.equal(result.defuzzified, 'notCold');
+    assert.equal(result.fuzzified, 1); // But fuzzified is the shape's value, not NOT result
+    
+    // At 20°C, cold = 0, so NOT cold = 1
+    const result2 = logic.defuzzify(20);
+    assert.equal(result2.defuzzified, 'notCold');
+  });
+});