fixed scale, removed Rule in favor of parametrized functions in rules.py

Author: amogorkon

Showcase.ipynb

@@ -105,6 +105,14 @@ def __delattr__(self, name):
         else:
             raise FuzzyWarning("Trying to delete a regular attr, this needs extra care.")
 
+    def range(self):
+        """Return an arange object with the domain's specifics.
+        
+        This is used to conveniently iterate over all possible values
+        for plotting etc.
+        """
+        return arange(self.low, self.high, self.res)
+            
     def MIN(self, x):
         """Standard way to get the min over all membership funcs.
         
@@ -263,18 +271,14 @@ def relative_cardinality(self):
             raise FuzzyWarning("The domain has no element.")
         return self.cardinality() / len(self)
 
-    def plot(self, low=None, high=None, res=None):
+    def plot(self):
         """Graph the set.
         Use the bounds and resolution of the domain to display the set
         unless specified otherwise.
         """
         if self.domain is None:
             raise FuzzyWarning("No domain assigned, cannot plot.")
-
-        low = self.domain.low if low is None else low
-        high = self.domain.high if high is None else high
-        res = self.domain.res if res is None else res
-        R = arange(low, high, res)
+        R = self.domain.range()
         V = [self.func(x) for x in R]
         plt.plot(R, V)
 
@@ -323,41 +327,6 @@ def normalized(self):
                             domain=self.domain,
                             name=f"normalized_{self.name}")
 
-class Rule:
-    """
-    A rule is used to combine fuzzysets of different domains, aggregating the
-    results of the previous calculations.
-
-    It works like this:
-    >>> temp = Domain("temperature", 0, 100)
-    >>> temp.hot = Set(lambda x: 1)
-    >>> dist = Domain("distance", 0, 300)
-    >>> dist.close = Set(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.
-    """
-    def __init__(self, *, OR:callable, AND:callable, IN:list, OUT:list):
-        self.OR = OR
-        self.AND = AND
-        self.IN = IN
-        self.OUT = OUT
-
-    def evaluate(self):
-        pass
-
-    def plot(self):
-        pass
-
-
 if __name__ == "__main__":
     import doctest
     doctest.testmod()

fuzzy/classes.py

@@ -26,31 +26,32 @@ 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 scale(out_min, out_max, *, in_min=0, in_max=1):
     """Scale from one domain to another.
     
-    Works best for [0,1] -> R. 
+    Tests only cover scaling from [0,1] (with default in_min, in_max!)
+    to R.
     
-    For R -> R additional testing is required, 
+    For arbitrary R -> R additional testing is required,
     but it should work in general out of the box.
     
-    Originally used the naive algo from SO
+    Originally used the algo from SO
     (OUT_max - OUT_min)*(x - IN_min) / (IN_max - IN_min) + OUT_min
     but there are too many edge cases thanks to over/underflows.
     Current factorized algo was proposed as equivalent by wolframalpha, 
     which seems more stable.
     """
-    assert IN_min < IN_max
+    assert in_min < in_max
+    
+    # for easier handling of the formula
+    a = out_min
+    b = out_max
+    c = in_min
+    d = in_max
 
     def f(x):
-        if x == IN_min:
-            return OUT_min
-        elif x == IN_max:
-            return OUT_max
-        return (OUT_min * IN_min - OUT_min * x - 
-         2 * OUT_max *  IN_min + OUT_max * IN_max + IN_max * x) / (
-            IN_max - IN_min)
-        
+        y = (a*d - a*x - b*c + b*x) / (d - c)
+        return y
     return f
 
 

fuzzy/rules.py

@@ -312,12 +312,15 @@ def test_repr_unassigned(self):
 
     @given(st.floats(allow_nan=False, allow_infinity=False),
            st.floats(allow_nan=False, allow_infinity=False),
-          st.floats(min_value=0.000001, max_value=1))
+          st.floats(min_value=0.0001, max_value=1))
     def test_eq(self, low, high, res):
-        """This also tests Set.array()."""
+        """This also tests Set.array().
+        This test can massively slow down hypothesis with even 
+        reasonably large/small values.
+        """
         assume(low < high)
         # to avoid MemoryError and runs that take forever..
-        assume(high - low <= 1000)
+        assume(high - low <= 100)
         D1 = Domain("1", low, high, res=res)
         D1.s1 = Set(fun.bounded_linear(low, high))
         D2 = Domain("2", low, high, res=res)
@@ -349,16 +352,16 @@ def test_complement(self):
 
 class Test_Rules(TestCase):
     @given(st.floats(min_value=0, max_value=1),
-           st.floats(min_value=0, max_value=1),
-           st.floats(min_value=0, max_value=1),
            st.floats(allow_infinity=False, allow_nan=False),
-          st.floats(allow_infinity=False, allow_nan=False))
-    def test_scaling(self, x, IN_min, IN_max, OUT_min, OUT_max):
-        assume(IN_min < IN_max)
-        assume(IN_min <= x <= IN_max)
-        assume(OUT_min < OUT_max)
-        f = ru.scale(OUT_min, OUT_max, IN_min=IN_min, IN_max=IN_max) 
-        assert (OUT_min <= f(x) <= OUT_max)
+           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):
+        assume(in_min < in_max)
+        assume(in_min <= x <= in_max)
+        assume(out_min < out_max)
+        f = ru.scale(out_min, out_max) 
+        assert (out_min <= f(x) <= out_max)
 
     @given(st.floats(allow_nan=False),
           st.floats(allow_nan=False))