added set ops

Author: amogorkon

Showcase.ipynb

@@ -1,10 +1,11 @@
 
 import matplotlib.pyplot as plt
-from numpy import arange, fromiter, array_equal
+from numpy import arange, fromiter, array_equal, less_equal, greater_equal, less, greater
+import numpy as np
 from logging import warn
 import pickle
 
-from fuzzy.functions import inv
+from fuzzy.functions import inv, normalize
 from fuzzy.combinators import MAX, MIN, product, bounded_sum
 
 class FuzzyWarning(UserWarning):
@@ -179,7 +180,7 @@ def __pow__(self, power):
         return Set(lambda x: pow(self.func(x), power))
 
     def __eq__(self, other):
-        """A set is equal with another if it returns exactly the same values."""
+        """A set is equal with another if both return the same values over the same range."""
         if self.domain is None or other.domain is None:
             # It would require complete AST analysis to check whether both Sets
             # represent the same recursive functions - 
@@ -190,7 +191,37 @@ def __eq__(self, other):
             # however, if domains ARE assigned (whether or not it's the same domain), 
             # we simply can check if they map to the same values 
             return array_equal(self.array(), other.array())
+        
+    def __le__(self, other):
+        """If this is less than other, it means this is a subset of the other."""
+        if self.domain is None or other.domain is None:
+            raise FuzzyWarning("Can't compare without Domains.")
+        return all(less_equal(self.array(), other.array()))
+    
+    def __lt__(self, other):
+        """If this is less than other, it means this is a subset of the other."""
+        if self.domain is None or other.domain is None:
+            raise FuzzyWarning("Can't compare without Domains.")
+        return all(less(self.array(), other.array()))
+    
+    def __ge__(self, other):
+        """If this is greater than other, it means this is a superset of the other."""
+        if self.domain is None or other.domain is None:
+            raise FuzzyWarning("Can't compare without Domains.")
+        return all(greater_equal(self.array(), other.array()))
 
+    def __gt__(self, other):
+        """If this is less than other, it means this is a subset of the other."""
+        if self.domain is None or other.domain is None:
+            raise FuzzyWarning("Can't compare without Domains.")
+        return all(greater(self.array(), other.array()))
+    
+    def __len__(self):
+        if self.domain is None:
+            raise FuzzyWarning("No domain, can't determine length.")
+        return len(self.array())
+        
+        
     def plot(self, low=None, high=None, res=None):
         """Graph the set.
         Use the bounds and resolution of the domain to display the set
@@ -219,7 +250,9 @@ def __repr__(self):
         Return a string representation of the Set that reconstructs the set with eval().
         
         *******
-        this is harder than expected since all functions are (recursive!) closures which
+        Current implementation does NOT work correctly.
+        
+        This is harder than expected since all functions are (recursive!) closures which
         can't simply be pickled. If this functionality really is needed, all functions 
         would have to be peppered with closure-returning overhead such as
         
@@ -232,15 +265,21 @@ def create_function_closure():
             func = types.FunctionType(*args[:-1] + [closure])
             return func
         """
-        return NotImplemented
-        #return f"Set({}, domain={self.domain}, name={self.name})"
+        return f"Set({self.func}, domain={self.domain}, name={self.name})"
 
     def __str__(self):
         if self.name is None and self.domain is None:
             return f"dangling Set({self.func})"
         else:
             return f"{self.domain}.{self.name}"
-
+        
+    def normalized(self):
+        if self.domain is None:
+            raise FuzzyWarning("Can't normalize without domain.")
+        else:
+            return Set(normalize(max(self.array()), self.func), 
+                            domain=self.domain,
+                            name=f"normalized_{self.name}")
 
 class Rule:
     """

fuzzy/classes.py

@@ -22,6 +22,7 @@
 
 The intervals with non-zero m are called 'support', short s_m
 The intervals with m == 1 are called 'core', short c_m
+The intervals with max(m) are called "height"
 The intervals  m != 1 and m != 0 are called 'boundary'.
 The intervals with m == 0 are called 'unsupported', short no_m
 
@@ -83,6 +84,13 @@ def f(x):
             return func(x)
     return f
 
+def normalize(height, func):
+    assert 0 < height <= 1
+    
+    def f(x):
+        return func(x) / height
+    return f
+    
 ########################
 # MEMBERSHIP FUNCTIONS #
 ########################

fuzzy/functions.py

@@ -29,8 +29,7 @@ def test_constant(self, x, c):
 
     @given(st.floats(allow_nan=False),
             st.floats(min_value=0, max_value=1),
-            st.floats(min_value=0, max_value=1),
-           )
+            st.floats(min_value=0, max_value=1))
     def test_alpha(self, x, lower, upper):
         assume(lower < upper)
         f = fun.alpha(lower, upper, fun.noop())
@@ -40,6 +39,13 @@ def test_alpha(self, x, lower, upper):
             assert f(x) == upper
         else:
             assert f(x) == x
+            
+    @given(st.floats(allow_nan=False),
+            st.floats(min_value=0, max_value=1))
+    def test_normalize(self, x, height):
+        assume(0 < height)
+        f = fun.normalize(height, fun.alpha(0, height, fun.R(0,100)))
+        assert (0 <= f(x) <= 1)       
 
     @given(st.floats(),
            st.floats(),
@@ -291,4 +297,20 @@ def test_eq(self, low, high, res):
         D1.s1 = Set(fun.bounded_linear(low, high))
         D2 = Domain("2", low, high, res=res)
         D2.s2 = Set(fun.bounded_linear(low, high))
-        assert(D1.s1 == D2.s2)
+        assert(D1.s1 == D2.s2)
+    
+    def test_normalized(self):
+        D = Domain("d", 0, 10, res=0.1)
+        D.s = Set(fun.bounded_linear(3, 12))
+        x = D.s.normalized()
+        y = x.normalized()
+        
+        assert (set(D._sets.keys()) == set(["s", "normalized_s", "normalized_normalized_s"]))
+        assert x == y
+        
+    def test_sub_super_set(self):
+        D = Domain("d", 0, 10, res=0.1)
+        D.s = Set(fun.bounded_linear(3, 12))
+        x = D.s.normalized()
+        assert (x >= D.s)
+        assert (D.s <= x)