completed weighted_sum roundtrip

Author: amogorkon

fuzzy/classes.py

@@ -113,7 +113,7 @@ def range(self):
         """
         return arange(self.low, self.high, self.res)
 
-    def MIN(self, x):
+    def min(self, x):
         """Standard way to get the min over all membership funcs.
         
         It's not just more convenient but also faster than
@@ -122,7 +122,7 @@ def MIN(self, x):
         """
         return min(f(x) for f in self._sets.values())
 
-    def MAX(self, x):
+    def max(self, x):
         """Standard way to get the max over all membership funcs.
         """
         return max(f(x) for f in self._sets.values())

fuzzy/rules.py

@@ -26,7 +26,7 @@ def round_partial(value, res):
         return value
     return round(value / res) * res
 
-def scale(out_min, out_max, *, in_min=0, in_max=1):
+def rescale(out_min, out_max, *, in_min=0, in_max=1):
     """Scale from one domain to another.
     
     Tests only cover scaling from [0,1] (with default in_min, in_max!)
@@ -66,9 +66,10 @@ def weighted_sum(*, weights:dict, target:Domain) -> float:
     there MUST be at least as many items in weights as factors.
     """
     assert sum(w for w in weights.values()) == 1
-    S = scale(target.low, target.high)
+
+    rsc = rescale(target.low, target.high)
 
-    def f(factors):
-        RES = sum(r * weights[n] for n, r in factors.items())
-        return S(round_partial(RES, target.res))
+    def f(memberships):
+        result = sum(r * weights[n] for n, r in memberships.items())
+        return round_partial(rsc(result), target.res)
     return f

test_fuzzy_functionality.py

@@ -6,7 +6,7 @@
 from unittest import TestCase, skip
 
 from fuzzy.classes import Domain, Set
-from fuzzy.rules import scale
+from fuzzy.rules import rescale, weighted_sum
 from fuzzy.functions import R, S, bounded_linear
 
 class TestTop(TestCase):
@@ -20,22 +20,38 @@ def setUp(self):
     def test_temp(self):
         assert(self.temp(6) == {'cold': 0.6, 'hot': 0, 'warm': 0.4})
 
-class Test_Meal(TestCase):
+class Test_Weighted(TestCase):
     def setUp(self):
         """Tom is surveying restaurants. 
-        He doesn't need fancy logic but rather uses a simple approach with weights.
-        He went into a small, dirty bar that served some delicious drink and food.
+        He doesn't need fancy logic but rather uses a simple approach 
+        with weights.
+        He went into a small, dirty bar that served some 
+        really good drink and food that wasn't nicely arranged but still
+        yummmy. He rates the different factors on a scale from 1 to 10,
+        uses a bounded_linear function to normalize over [0,1] and
+        passes both the weights (how much each aspect should weigh in total)
+        and the domain as parameters into weighted_sum.
+        However, he can't just use Domain(value) because that would return
+        a dict of memberships, instead he uses Domain.min(value) which
+        returns the minimum of all memberships no matter how many sets
+        there are. He creates a dict of membership values corresponding to
+        the weights and passes that into the parametrized weighted_sum func
+        as argument to get the final rating for this restaurant.
         """
         self.R = Domain("rating", 1, 10, res=0.1)
         self.R.norm = Set(bounded_linear(1, 10))
         self.weights = weights = {"beverage": 0.3, 
                                   "atmosphere": 0.2, 
-                                   "arrangement":0.2,
+                                   "looks":0.2,
                                    "taste": 0.3}
-        self.ratings = {"beverage": self.R.MIN(7),
-                       "atmosphere": self.R.MIN(3),
-                       "arrangement": self.R.MIN(2),
-                       "taste": self.R.MIN(9)}
+        self.w_func = weighted_sum(weights=self.weights, target=self.R)      
+    
+    def test_rating(self):
+        ratings = {"beverage": self.R.min(9),
+                   "atmosphere": self.R.min(5),
+                   "looks": self.R.min(4),
+                    "taste": self.R.min(8)}
+        assert (self.w_func(ratings) == 6.9)
 
 if __name__ == '__main__':
     unittest.main()

test_fuzzy_units.py

@@ -356,11 +356,11 @@ class Test_Rules(TestCase):
            st.floats(allow_infinity=False, allow_nan=False),
            st.floats(min_value=0, max_value=1),
            st.floats(min_value=0, max_value=1))
-    def test_scale(self, x, out_min, out_max, in_min, in_max):
+    def test_rescale(self, x, out_min, out_max, in_min, in_max):
         assume(in_min < in_max)
         assume(in_min <= x <= in_max)
         assume(out_min < out_max)
-        f = ru.scale(out_min, out_max) 
+        f = ru.rescale(out_min, out_max) 
         assert (out_min <= f(x) <= out_max)
 
     @given(st.floats(allow_nan=False),