es6-fuzz 3.0.6 → 4.0.1

package/.jscsrc

@@ -14,7 +14,6 @@
     "disallowEmptyBlocks": true,
     "disallowSpacesInsideParentheses": true,
     "disallowSpaceAfterObjectKeys": true,
-    "requireSpaceAfterBinaryOperators": true,
     "disallowSpaceBeforePostfixUnaryOperators": ["++", "--"],
     "requireSpaceBeforeBinaryOperators": [
         "=",

package/Readme.md

@@ -58,6 +58,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,27 @@
+2022-06-14
+==========
+
+  * 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
+    letters
+
+2022-06-11
+==========
+
+  * (churn): changelog
+  * 3.0.7
+  * fix: revert dep change
+  * refactor: make dependencies lighter
+
 2022-06-02
 ==========
 
+  * 3.0.6
+  * (churn): changelog
   * feature: chehck if init was called before any logic os performed
   * test: add another example to the tests
   * chore: remove travis config
@@ -129,28 +150,3 @@
   * 2.5.7
   * 2.5.6
   * Added docs
-  * Fix output ght pages
-  * DOcs
-  * Ghpages
-  * 2.5.5
-  * Autorelease
-
-2017-01-27
-==========
-
-  * (churn): changelog
-  * 2.5.4
-  * Merge branch 'master' of github.com:sebs/es6-fuzz
-  * Merge pull request [#64](https://github.com/sebs/es6-fuzz/issues/64) from sebs/greenkeeper-browserify-14.0.0
-    Update browserify to version 14.0.0 🚀
-
-2017-01-25
-==========
-
-  * chore(package): update browserify to version 14.0.0
-    https://greenkeeper.io/
-
-2017-01-09
-==========
-
-  * (churn): changelog

package/lib/logic.js

@@ -48,40 +48,51 @@ class Logic {
     }
   }
 
+  checkOutputName(name) {
+    const reg = /^[a-z]+$/i;
+    if (!reg.test(name)) {
+      throw Error('Output names can only be strings without space, without numbers and without special chars');
+    }
+  }
+
+  
+
   init(output, shape) {
+    this.checkOutputName(output);
     this.initCalled = true;
     let type = TYPE_INIT;
     this.rules.push({ output, shape, type });
     return this;
   }
   and(output, shape) {
+    this.checkOutputName(output);
     this.checkInitCalled();
     let type = TYPE_AND;
     this.rules.push({ output, shape, type });
     return this;
   }
-  or(output, shape) {
+  or(output, shape) {+
+    this.checkOutputName(output);
     this.checkInitCalled();
     let type = TYPE_OR;
     this.rules.push({ output, shape, type });
     return this;
   }
   not(output, shape) {
+    this.checkOutputName(output);
     this.checkInitCalled();
     let type = TYPE_NOT;
     this.rules.push({ output, shape, type });
     return this;
   }
-  defuzzify(value) {
+  defuzzify(value, as=undefined) {
     this.checkInitCalled();
     let defuzzified = 'none';
     let fuzzified = 0;
     let lastShape;
-
     this.rules.forEach(rule => {
       rule.fuzzy = rule.shape.fuzzify(value);
       // lets keep the initial value
-  
       if (rule.type === TYPE_INIT) {
         defuzzified = rule.output;
         fuzzified = rule.fuzzy;
@@ -97,14 +108,28 @@ class Logic {
         defuzzified = rule.output;
         fuzzified = rule.fuzzy;
         // if there is no shape, like for example for a NOT keep the last one
-        lastShape = rule.shape || lastShape;
+        lastShape = rule.shape || lastShape;
       }
     });
+
+
+
+    var namePrefix = '';
+    if (!!as && typeof as === 'string') {
+      namePrefix = as + '.';
+    }
+
+    const boonJsInputs = {};
+    this.rules.forEach(rule => { 
+      boonJsInputs[`${namePrefix}${rule.output}`] = rule.output === defuzzified;
+    });
+
     /**
      *
      * @example  fuzzy.defuzzify(10)
      */
     return {
+      boonJsInputs,
       fuzzified: fuzzified,
       defuzzified: defuzzified,
       rules: this.rules,

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "es6-fuzz",
   "description": "fuzzy logic with and for es6",
-  "version": "3.0.6",
+  "version": "4.0.1",
   "main": "lib/logic.js",
   "repository": "git@github.com:sebs/es6-fuzz.git",
   "homepage": "https://github.com/sebs/es6-fuzz",
   "scripts": {
-    "env": "env",
-    "changelog": "rm ./docs/CHANGELOG.md && changelog https://github.com/sebs/es6-fuzz all > ./docs/CHANGELOG.md && git add . && git commit . -m '(churn): changelog'",
-    "test": "mocha -r blanket",
+    "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",
     "addpush": "git add . && git commit . -m 'docs'",
     "pages": "node ./scripts/publish-gh.js",
@@ -23,32 +22,14 @@
     "javascript",
     "es6"
   ],
-  "config": {
-    "blanket": {
-      "pattern": "lib/*",
-      "data-cover-never": [
-        "node_modules",
-        "tests"
-      ]
-    }
-  },
   "author": "Sebastian Schürmann",
   "license": "MIT",
   "devDependencies": {
-    "browserify": "17.0.0",
-    "changelog": "1.4.2",
-    "documentation": "13.2.5",
-    "es6ify": "1.6.0",
-    "eslint": "8.16.0",
     "gh-pages": "4.0.0",
     "ink-docstrap": "1.3.2",
-    "jscs": "3.0.7",
-    "jsdoc": "3.6.10",
-    "mocha": "10.0.0",
-    "mocha-traceur": "2.1.0",
-    "traceur": "0.0.111"
+    "jsdoc": "3.6.10"
   },
   "dependencies": {
-    "blanket": "1.2.3"
+    "boon-js": "2.0.3"
   }
 }

package/test/js-bool.test.js

@@ -0,0 +1,86 @@
+'use strict';
+const Logic = require('../lib/logic');
+const Triangle = require('../lib/curve/triangle');
+const Trapezoid = require('../lib/curve/trapezoid');
+const assert = require('assert');
+const getEvaluator = require('boon-js').getEvaluator;
+
+describe('js-bool test', () => {
+    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)
+    
+    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)
+
+
+    it('provides output for js-bool', () => { 
+        const res = logicHeat.defuzzify(20, 'heat');
+        assert.ok(res.boonJsInputs);
+    })
+
+    it('jsbool output cold is false', () => { 
+        const res = logicHeat.defuzzify(20);
+        assert.equal(res.boonJsInputs.cold, false);
+    })
+
+    it('jsbool output hot is false', () => { 
+        const res = logicHeat.defuzzify(20);
+        assert.equal(res.boonJsInputs.cold, false);
+    })
+
+    it('jsbool output optimal is false', () => { 
+        const res = logicHeat.defuzzify(20);
+        assert.equal(res.boonJsInputs.optimal, true);
+    })
+
+    it('jsbool output cold as heat is false', () => { 
+        const res = logicHeat.defuzzify(20, 'heat');
+        assert.equal(res.boonJsInputs['heat.cold'], false);
+    })
+
+    it('jsbool output hot as heat is false', () => { 
+        const res = logicHeat.defuzzify(20, 'heat');
+        assert.equal(res.boonJsInputs['heat.hot'], false);
+    })
+
+    it('jsbool output optimal as heat is true', () => { 
+        const res = logicHeat.defuzzify(20, 'heat');
+        assert.equal(res.boonJsInputs['heat.optimal'], true);
+    });
+
+
+    describe('can combine 2 fuzzy decisions via boonJs', ()=>{
+        it.only('monster bites when heat is cold and distance is close', ()=>{
+            
+            const resHeat = logicHeat.defuzzify(2, 'heat');
+            const resClose = logicDistance.defuzzify(2, 'distance');
+            
+            const jsBoonInput = { ...resHeat.boonJsInputs, ...resClose.boonJsInputs }
+            console.log(jsBoonInput);
+
+            const monsterBiteTest = getEvaluator(
+                'heat.cold AND distance.close',
+            );
+
+            const monsterSleepTest = getEvaluator(
+                'heat.hot AND distance.far',
+            );
+
+            const resBite = monsterBiteTest(jsBoonInput)
+            assert.equal(resBite, true);
+
+            const resSleep = monsterSleepTest(jsBoonInput)
+            assert.equal(resSleep, false);
+        });
+    });
+});

package/test/logic-test.js

@@ -43,9 +43,9 @@ describe('logic', () => {
       var logic = new Logic();
       var res = logic
         .init('rage', rageRange)
-        .not('no rage', rageRange)
+        .not('norage', rageRange)
         .defuzzify(20);
-      assert.equal(res.toString(), 'no rage');
+      assert.equal(res.toString(), 'norage');
     });
   });