added hedge tests.

Author: amogorkon

Showcase.ipynb

@@ -61,10 +61,9 @@ def __init__(self, name, low, high, res=1):
     def __call__(self, x):
         if not(self.low <= x <= self.high):
             warn(f"{x} is outside of domain!")
-        set_memberships = {}
-        for setname, s in self._sets.items():
-            set_memberships["{0}.{1}".format(self.name, setname)] = s(x)
-        return set_memberships
+        memberships = {name: s.func(x) for 
+                        name, s, in self._sets.items()}
+        return memberships
 
     def __str__(self):
         return self.name

fuzzy/classes.py

@@ -3,22 +3,26 @@
 -----------
 COMBINATORS
 -----------
-Linguistic terms (membership functions of two different FuzzySets) 
-are combined with these functions to implement rules.
+Linguistic terms (membership functions of two different FuzzySets of the same domain) 
+are combined.
 
 a and b are functions.
+
+Since these combinators are used directly in the Set class to implement logic operations, 
+the most obvious use of this module is when subclassing Set to make use of specific combinators
+for special circumstances.
 """
 
 
 def MIN(a, b):
-    """Simple AND of two functions a and b."""
+    """Classic AND variant."""
     def f(x):
         return min(a(x), b(x))
     return f
 
 
 def MAX(a, b):
-    """Simple OR of two functions a and x."""
+    """Classic OR variant."""
     def f(x):
         return max(a(x), b(x))
     return f
@@ -38,51 +42,44 @@ def f(x):
         return a_x + b_x - a_x * b_x
     return f
 
-
-def lukasiewicz_OR(a, b):
-    """OR variant."""
-    def f(x):
-        return max(0, a(x) + b(x) - 1)
-    return f
-
-
 def lukasiewicz_AND(a, b):
     """AND variant."""
     def f(x):
         return min(1, a(x) + b(x))
     return f
 
-
-def einstein_sum(a, b):
+def lukasiewicz_OR(a, b):
     """OR variant."""
     def f(x):
-        a_x, b_x = a(x), b(x)
-        return (a_x + b_x) / (1 + a_x * b_x)
+        return max(0, a(x) + b(x) - 1)
     return f
 
-
 def einstein_product(a, b):
     """AND variant."""
     def f(x):
         a_x, b_x = a(x), b(x)
         return (a_x * b_x) / (2 - (a_x + b_x - a_x * b_x))
     return f
 
-
-def hamacher_sum(a, b):
+def einstein_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)
+        return (a_x + b_x) / (1 + a_x * b_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)
 
+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)
+    return f
 
 def lambda_op(a, b, l):
     """A 'compensatoric' operator, combining AND with OR by a weighing factor l.
@@ -105,4 +102,4 @@ 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
+    return f

fuzzy/combinators.py

@@ -5,7 +5,7 @@
 -------------------
 Functions that transform a given membership value to a truth value.
 
-How this can be useful? Well.. 
+How this can be useful? Beats me. Found it somewhere on the internet, never needed it.
 """
 
 

fuzzy/truth.py

@@ -14,7 +14,9 @@ def setUp(self):
         Lucy tells her robot that it is good to heat when it's cold and not when it's hot."""
         self.temp = Domain('temperature', -100, 100, 1)  # in Celsius
         self.temp.cold = Set(S(0, 15))
-        self.temp.hot = Set(R(10, 20))
+        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})
 
     def test_temp(self):
         # we need to define a dictionary-aggregation func here

test_fuzzy_functionality.py

@@ -3,7 +3,9 @@
 from math import isclose
 from unittest import TestCase
 
+from fuzzy.classes import Domain, Set, Rule
 from fuzzy import functions as fun
+from fuzzy import hedges
 
 class Test_Functions(TestCase):
     @given(st.floats(allow_nan=False))
@@ -108,7 +110,7 @@ def test_triangular(self, x, low, high, c, c_m, no_m):
       st.floats(allow_nan=False, allow_infinity=False),
       st.floats(allow_nan=False, allow_infinity=False),
       st.floats(allow_nan=False, allow_infinity=False),
-      st.floats(min_value=0, max_value=1),
+      st.floats(allow_nan=False, allow_infinity=False),
       st.floats(min_value=0, max_value=1),
       st.floats(min_value=0, max_value=1))
     def test_trapezoid(self, x, low, c_low, c_high, high, c_m, no_m):
@@ -152,9 +154,31 @@ def test_triangular_sigmoid(self, x, low, high, c):
     @given(st.floats(allow_nan=False),
       st.floats(allow_nan=False, allow_infinity=False),
       st.floats(allow_nan=False, allow_infinity=False),
-      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 < c_m <= 1)
         assume(0 < b)
         f = fun.gauss(c, b, c_m=c_m)
-        assert (0 <= f(x) <= 1)
+        assert (0 <= f(x) <= 1)
+
+class Test_Hedges(TestCase):
+    @given(st.floats(allow_nan=False))
+    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))
+    def test_minus(self, x):
+        assume(0 <= x <= 1)
+        s = Set(fun.noop())
+        h = hedges.minus(s)
+        assert (0 <= h(x) <= 1)
+        
+    @given(st.floats(allow_nan=False))
+    def test_plus(self, x):
+        assume(0 <= x <= 1)
+        s = Set(fun.noop())
+        h = hedges.plus(s)
+        assert (0 <= h(x) <= 1)