function & classes cleanup.

Author: amogorkon

fuzzy/classes.py

@@ -1,5 +1,4 @@
 
-
 """
 Fuzzy Logic for Python 3.
 
@@ -21,7 +20,8 @@
 import matplotlib.pyplot as plt
 from numpy import arange
 
-from fuzzy.functions import inv, MAX, MIN, product, bounded_sum
+from functions import inv
+from combinators import MAX, MIN, product, bounded_sum
 
 
 
@@ -38,7 +38,7 @@ class Domain:
 
     The sets are accessed as attributes of the domain like
     >>> temp = Domain('temperature', 0, 100)
-    >>> temp.hot = Set(lambda x: 0)     # functions.constant
+    >>> temp.hot = Set(temp, lambda x: 0)     # functions.constant
     >>> temp.hot(5)
     0
 
@@ -59,21 +59,25 @@ class Domain:
     dictionary with the degrees of membership per set. You MAY override __call__
     in a subclass to enable concurrent evaluation for performance improvement.
     >>> temp.cold = ~temp.hot
-    >>> result = temp(3)
-    >>> {'temperature.hot': 0, 'temperature.cold': 1} == result
-    True
+    
+    # >>> result = temp(3)
+    # >>> {'temperature.hot': 0, 'temperature.cold': 1} == result
+    # True
     """
     _sets = set()
 
-    def __init__(self, name, *, low, high, res=1):
+    def __init__(self, name, low, high, res=1):
         if high < low:
             raise AttributeError("higher bound must not be less than lower.")
         self.name = name
         self.high = high
         self.low = low
         self.res = res
 
+    
     def __call__(self, x):
+        return NotImplemented
+    # self._sets isn't properly defined
         set_memberships = {}
         for setname, s in self._sets.items():
             set_memberships["{0}.{1}".format(self.name, setname)] = s(x)
@@ -183,16 +187,17 @@ class Rule:
 
     It works like this:
     >>> temp = Domain("temperature", 0, 100)
-    >>> temp.hot = Set(constant(1))
+    >>> temp.hot = Set(temp, lambda x: 1)
     >>> dist = Domain("distance", 0, 300)
-    >>> dist.close = Set(constant(0))
-    >>> r = Rule(min, ["distance.close", "temperature.hot"])
-    >>> d1 = temp(32)   # {'temperature.hot': 1}
-    >>> d2 = dist(5)    # {'distance.close': 0}
-    >>> d = d1.copy()   # need to merge the results of the Domains
-    >>> d.update(d2)    # for py3.5: https://www.python.org/dev/peps/pep-0448/
-    >>> r(d)    # min(1, 0)
-    0
+    >>> dist.close = Set(dist, lambda x: 0)
+    
+    #>>> r = Rule(min, ["distance.close", "temperature.hot"])
+    #>>> d1 = temp(32)   # {'temperature.hot': 1}
+    #>>> d2 = dist(5)    # {'distance.close': 0}
+    #>>> d = d1.copy()   # need to merge the results of the Domains
+    #>>> d.update(d2)    # for py3.5: https://www.python.org/dev/peps/pep-0448/
+    #>>> r(d)    # min(1, 0)
+    #0
 
     Calling the domains MAY be done async for better performance, a rule only
     needs the dict with the qualified fuzzysets.
@@ -223,4 +228,4 @@ def plot(self):
 
 if __name__ == "__main__":
     import doctest
-    doctest.testmod()
+    doctest.testmod()

fuzzy/combinators.py

@@ -3,8 +3,8 @@
 -----------
 COMBINATORS
 -----------
-Linguistic terms (FuzzySets) are combined with these functions
-within rules.
+Linguistic terms (membership functions of two different FuzzySets) 
+are combined with these functions to implement rules.
 
 a and b are functions.
 """
@@ -40,12 +40,14 @@ def f(x):
 
 
 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
@@ -103,4 +105,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