added tests for combinators

Author: amogorkon

Showcase.ipynb

@@ -1,19 +1,23 @@
 do: build a #testcase suite
 ---
-do: MUST review #functions
----
 do: #Set.plot SHOULD always plot between 0 and 1
 ---
 do: #Set.plot SHOULD always plot the full set range
 ---
-do: MUST fix #Domain._sets (should be either set OR dict)
-until: 2017-3-1
-requires: Set.plot testcase 
----
 do: check tests
 after: 2017-3-1
 repeat: dayly
 until: end of year
 ---
 do: SHOULD find examples for truth functions
----
+---
+
+---
+do: MUST review #functions
+done: yes
+---
+do: MUST fix #Domain._sets (should be either set OR dict)
+until: 2017-3-1
+requires: Set.plot testcase 
+done: yes
+---

TODO-fuzzy

@@ -69,37 +69,55 @@ def f(x):
     return f
 
 def hamacher_product(a, b):
-    """AND variant."""
-    def f(x):
-        a_x, b_x = a(x), b(x)
-        return (a_x * b_x) / (a_x + b_x - a_x * b_x)
+    """AND variant.
+    (xy) / (x + y - xy) for x, y != 0
+    0 otherwise
+    """
+    def f(z):
+        x, y = a(z), b(z)
+        return (x * y) / (x + y - x * y) if x != 0 and y != 0 else 0
+    return f
 
 def hamacher_sum(a, b):
-    """OR variant."""
-    def f(x):
-        a_x, b_x = a(x), b(x)
-        return (a_x + b_x - 2 * a_x * b_x) / (1 - a_x * b_x)
+    """OR variant.
+    (x + y - 2xy) / (1 - xy) for x,y != 1
+    1 otherwise
+    """
+    def f(z):
+        x, y = a(z), b(z)
+        return (x + y - 2 * x * y) / (1 - x * y) if x != 1 or y != 1 else 1
     return f
 
-def lambda_op(a, b, l):
+
+def lambda_op(l):
     """A 'compensatoric' operator, combining AND with OR by a weighing factor l.
+    
+    This complicates matters a little, since all combinators promise to just take 
+    2 functions as arguments, so we parametrize this with l.
     """
-    def f(x):
-        a_x, b_x = a(x), b(x)
-        return l * (a_x * b_x) + (1 - l) * (a_x + b_x - a_x * b_x)
-    return f
+    assert (0 <= l <= 1)
+        
+    def e(a, b):
+        def f(x):
+            a_x, b_x = a(x), b(x)
+            return l * (a_x * b_x) + (1 - l) * (a_x + b_x - a_x * b_x)
+        return f
+    return e
 
 
-def gamma_op(a, b, g):
+def gamma_op(g):
     """A 'compensatoric' operator, combining AND with OR by a weighing factor g.
     g (gamma-factor)
         0 < g < 1 (g == 0 -> AND; g == 1 -> OR)
+        
+    Same problem as with lambda_op, since all combinators promise to just take 
+    2 functions as arguments, so we parametrize this with g.
     """
-    if not(0 <= g <= 1):
-        raise ValueError
-
-    def f(x):
-        a_x, b_x = a(x), b(x)
-        return (a_x * b_x) ** (1 - g) * ((1 - a_x) * (1 - b_x)) ** g
-
-    return f
+    assert (0 <= g <= 1)
+    
+    def e(a, b):
+        def f(z):
+            x, y = a(z), b(z)
+            return (x * y) ** (1 - g) * ((1 - x) * (1 - y)) ** g
+        return f
+    return e

fuzzy/combinators.py

@@ -15,12 +15,10 @@ def setUp(self):
         self.temp = Domain('temperature', -100, 100, 1)  # in Celsius
         self.temp.cold = Set(S(0, 15))
         self.temp.hot = Set(R(10, 30))
-        self.temp.warm = ~self.cold & ~self.hot
-        assert(temp(6) == {'cold': 0.6, 'hot': 0, 'warm': 0.4})
+        self.temp.warm = ~self.temp.cold & ~self.temp.hot
 
     def test_temp(self):
-        # we need to define a dictionary-aggregation func here
-        pass
+        assert(self.temp(6) == {'cold': 0.6, 'hot': 0, 'warm': 0.4})
 
 
 if __name__ == '__main__':

test_fuzzy_functionality.py

@@ -6,6 +6,7 @@
 from fuzzy.classes import Domain, Set, Rule
 from fuzzy import functions as fun
 from fuzzy import hedges
+from fuzzy import combinators as combi
 
 class Test_Functions(TestCase):
     @given(st.floats(allow_nan=False))
@@ -156,29 +157,116 @@ def test_triangular_sigmoid(self, x, low, high, c):
       st.floats(allow_nan=False, allow_infinity=False),
       st.floats(min_value=0, max_value=1))
     def test_gauss(self, x, b, c, c_m):
-        assume(0 < c_m <= 1)
         assume(0 < b)
+        assume(0 < c_m)
         f = fun.gauss(c, b, c_m=c_m)
         assert (0 <= f(x) <= 1)
 
 class Test_Hedges(TestCase):
-    @given(st.floats(allow_nan=False))
+    @given(st.floats(min_value=0, max_value=1))
     def test_very(self, x):
-        assume(0 <= x <= 1)
         s = Set(fun.noop())
-        h = hedges.very(s)
-        assert (0 <= h(x) <= 1)
-
-    @given(st.floats(allow_nan=False))
+        f = hedges.very(s)
+        assert (0 <= f(x) <= 1)
+        
+    @given(st.floats(min_value=0, max_value=1))
     def test_minus(self, x):
-        assume(0 <= x <= 1)
         s = Set(fun.noop())
-        h = hedges.minus(s)
-        assert (0 <= h(x) <= 1)
+        f = hedges.minus(s)
+        assert (0 <= f(x) <= 1)
 
-    @given(st.floats(allow_nan=False))
+    @given(st.floats(min_value=0, max_value=1))
     def test_plus(self, x):
-        assume(0 <= x <= 1)
         s = Set(fun.noop())
-        h = hedges.plus(s)
-        assert (0 <= h(x) <= 1)
+        f = hedges.plus(s)
+        assert (0 <= f(x) <= 1)
+
+
+class Test_Combinators(TestCase):
+    @given(st.floats(min_value=0, max_value=1))
+    def test_MIN(self, x):
+        a = fun.noop()
+        b = fun.noop()
+        f = combi.MIN(a, b)
+        assert (0 <= f(x) <= 1)
+
+    @given(st.floats(min_value=0, max_value=1))
+    def test_MAX(self, x):
+        a = fun.noop()
+        b = fun.noop()
+        f = combi.MAX(a, b)
+        assert (0 <= f(x) <= 1)
+    
+    @given(st.floats(min_value=0, max_value=1))
+    def test_product(self, x):
+        a = fun.noop()
+        b = fun.noop()
+        f = combi.product(a, b)
+        assert (0 <= f(x) <= 1)
+    
+    @given(st.floats(min_value=0, max_value=1))
+    def test_bounded_sum(self, x):
+        a = fun.noop()
+        b = fun.noop()
+        f = combi.bounded_sum(a, b)
+        assert (0 <= f(x) <= 1)
+
+    @given(st.floats(min_value=0, max_value=1))
+    def test_lukasiewicz_AND(self, x):
+        a = fun.noop()
+        b = fun.noop()
+        f = combi.lukasiewicz_AND(a, b)
+        assert (0 <= f(x) <= 1)
+
+    @given(st.floats(min_value=0, max_value=1))
+    def test_lukasiewicz_OR(self, x):
+        a = fun.noop()
+        b = fun.noop()
+        f = combi.lukasiewicz_OR(a, b)
+        assert (0 <= f(x) <= 1)
+        
+    @given(st.floats(min_value=0, max_value=1))
+    def test_einstein_product(self, x):
+        a = fun.noop()
+        b = fun.noop()
+        f = combi.einstein_product(a, b)
+        assert (0 <= f(x) <= 1)
+        
+    @given(st.floats(min_value=0, max_value=1))
+    def test_einstein_sum(self, x):
+        a = fun.noop()
+        b = fun.noop()
+        f = combi.einstein_sum(a, b)
+        assert (0 <= f(x) <= 1)
+        
+    @given(st.floats(min_value=0, max_value=1))
+    def test_hamacher_product(self, x):
+        a = fun.noop()
+        b = fun.noop()
+        f = combi.hamacher_product(a, b)
+        assert (0 <= f(x) <= 1)
+        
+    @given(st.floats(min_value=0, max_value=1))
+    def test_hamacher_sum(self, x):
+        a = fun.noop()
+        b = fun.noop()
+        f = combi.hamacher_sum(a, b)
+        assert (0 <= f(x) <= 1)
+        
+    @given(st.floats(min_value=0, max_value=1),
+          st.floats(min_value=0, max_value=1))
+    def test_lambda_op(self, x, l):
+        a = fun.noop()
+        b = fun.noop()
+        g = combi.lambda_op(l)
+        f = g(a, b)
+        assert (0 <= f(x) <= 1)
+        
+    @given(st.floats(min_value=0, max_value=1),
+          st.floats(min_value=0, max_value=1))
+    def test_gamma_op(self, x, g):
+        a = fun.noop()
+        b = fun.noop()
+        g = combi.gamma_op(g)
+        f = g(a, b)
+        assert (0 <= f(x) <= 1)