showcase

Author: amogorkon

docs/Showcase.ipynb

@@ -340,6 +340,79 @@
     "w_func(ratings)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here is a simple but fully working example with all moving parts, demonstrating the use in the context of an HVAC system.\n",
+    "\n",
+    "It also demonstrates the three different ways to set up complex combinations of rules: you can either define each rule one by one and then combine them via the | operator, or you can put the rules into a list and use sum(..) to combine them into one in a single step, or you can define one big and complex rule right from the start. Which way best suits your needs depends on how complex each rule is and how/where you define them in your code and whether you need to use them in different places in different combinations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-04-07T21:45:52.904997Z",
+     "iopub.status.busy": "2021-04-07T21:45:52.904298Z",
+     "iopub.status.idle": "2021-04-07T21:45:53.028508Z",
+     "shell.execute_reply": "2021-04-07T21:45:53.027448Z",
+     "shell.execute_reply.started": "2021-04-07T21:45:52.904955Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1611.3704197201866 None 1656.5076659966692 None => 1633.939042858428\n"
+     ]
+    }
+   ],
+   "source": [
+    "from fuzzylogic.classes import Domain, Set, Rule\n",
+    "from fuzzylogic.hedges import very\n",
+    "from fuzzylogic.functions import R, S\n",
+    "\n",
+    "temp = Domain(\"Temperature\", -80, 80)\n",
+    "hum = Domain(\"Humidity\", 0, 100)\n",
+    "motor = Domain(\"Speed\", 0, 2000)\n",
+    "\n",
+    "temp.cold = S(0,20)\n",
+    "temp.hot = R(15,30)\n",
+    "\n",
+    "hum.dry = S(20,50)\n",
+    "hum.wet = R(40,70)\n",
+    "\n",
+    "motor.fast = R(1000,1500)\n",
+    "motor.slow = ~motor.fast\n",
+    "\n",
+    "R1 = Rule({(temp.hot, hum.dry): motor.fast})\n",
+    "R2 = Rule({(temp.cold, hum.dry): very(motor.slow)})\n",
+    "R3 = Rule({(temp.hot, hum.wet): very(motor.fast)})\n",
+    "R4 = Rule({(temp.cold, hum.wet): motor.slow})\n",
+    "\n",
+    "rules = Rule({(temp.hot, hum.dry): motor.fast,\n",
+    "              (temp.cold, hum.dry): very(motor.slow),\n",
+    "              (temp.hot, hum.wet): very(motor.fast),\n",
+    "              (temp.cold, hum.wet): motor.slow,\n",
+    "             })\n",
+    "\n",
+    "rules == R1 | R2 | R3 | R4 == sum([R1, R2, R3, R4])\n",
+    "\n",
+    "values = {hum: 45, temp: 22}\n",
+    "print(R1(values), R2(values), R3(values), R4(values), \"=>\", rules(values))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "There are a few things to note in this example. Firstly, make sure to pass in the values as a single dictionary at the end, not as parameters.\n",
+    "If a rule has zero weight - in this example a temp of 22 results in cold weighted with S(0,20) as 0 - the Rule returns None, which makes sure this condition is ignored in subsequent calculations. Also you might notice that the result is a value of 1633, which is way more than motor.fast with R(1000,1500) would suggest. However, since the domain motor is defined between 0 and 2000, the center of gravity method used for evaluation takes many of the values between 1500 and 2000 weighted with 1 into account, giving this slightly unexpected result."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

src/fuzzylogic/classes.py

@@ -409,11 +409,12 @@ def __eq__(self, other):
     def __getitem__(self, key):
         return self.conditions[frozenset(key)]
 
-    def __call__(self, args:"dict[Domain]", method="cog"):
+    def __call__(self, args:"dict[Domain, float]", method="cog"):
         """Calculate the infered value based on different methods.
         Default is center of gravity.
         """
-        assert len(args) == max(len(c) for c in self.conditions.keys()), "Number of arguments must correspond to the number of domains!"
+        assert len(args) == max(len(c) for c in self.conditions.keys()), "Number of values must correspond to the number of domains defined as conditions!"
+        assert isinstance(args, dict), "Please make sure to pass in the values as a dictionary."
         if method == "cog":
             actual_values = {f: f(args[f.domain]) for S in self.conditions.keys() for f in S}
             weights = [(v, x) for K, v in self.conditions.items()