refactored classes and fixed domains.

Author: amogorkon

Showcase.ipynb

@@ -1,10 +1,13 @@
 
 import matplotlib.pyplot as plt
 from numpy import arange, fromiter
+from logging import warn
 
 from fuzzy.functions import inv
 from fuzzy.combinators import MAX, MIN, product, bounded_sum
 
+class FuzzyWarning(UserWarning):
+    pass
 
 
 class Domain:
@@ -20,137 +23,159 @@ class Domain:
 
     The sets are accessed as attributes of the domain like
     >>> temp = Domain('temperature', 0, 100)
-    >>> temp.hot = Set(temp, lambda x: 0)     # functions.constant
+    >>> temp.hot = Set(lambda x: 0)
     >>> temp.hot(5)
     0
 
     DO NOT call a derived set without assignment first as it WILL
     confuse the recursion and seriously mess up.
+    NOT: ~temp.hot(2) or ~(temp.hot.)(2) but:
     >>> not_hot = ~temp.hot
     >>> not_hot(2)
     1
 
     You MUST NOT add arbitrary attributes to an *instance* of Domain - you can
-    however subclass or modify the class itself, which affects its instances:
-    >>> d = Domain('d', 0, 100)
-    >>> Domain.x = 78
-    >>> d.x
-    78
+    however subclass or modify the class itself. If you REALLY have to add attributes, 
+    make sure to "whitelist" it in _allowed_attrs first. 
 
     Use the Domain by calling it with the value in question. This returns a
     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
+    >>> temp.cold = not_hot
     
-    # >>> result = temp(3)
-    # >>> {'temperature.hot': 0, 'temperature.cold': 1} == result
+    # >>> temp(3) == {'temperature.hot': 0, 'temperature.cold': 1}
     # True
     """
-    _sets = set()
+    _allowed_attrs = ['name', 'low', 'high', 'res', '_sets']
 
     def __init__(self, name, low, high, res=1):
-        if high < low:
-            raise AttributeError("higher bound must not be less than lower.")
+        assert low < high, "higher bound must be greater than lower."
         self.name = name
         self.high = high
         self.low = low
         self.res = res
+        # one should not access (especially add things) directly
+        self._sets = {}
 
 
     def __call__(self, x):
-        return NotImplemented
-    # self._sets isn't properly defined
+        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
 
     def __str__(self):
-        return "Domain(%s)" % self.name
+        return self.name
 
     def __getattr__(self, name):
         if name in self._sets:
             return self._sets[name]
         else:
-            raise AttributeError("not a set and not an attribute")
-
-"""
+            raise AttributeError(f"{name} is not a set or attribute")
+            
     def __setattr__(self, name, value):
         # it's a domain attr
-        if name in ['name', 'low', 'high', 'res', '_sets']:
+        if name in self._allowed_attrs:
             object.__setattr__(self, name, value)
-        # we've got a fuzzyset within this domain and the value is a func
+        # we've got a fuzzyset
         else:
             if not isinstance(value, Set):
-                raise ValueError("only a fuzzy.Set may be assigned.")
+                raise ValueError(f"({name}) {value} must be a Set")
             self._sets[name] = value
             value.domain = self
-"""
+            value.name = name
+            
+    def __delattr__(self, name):
+        if name in self._sets:
+            del self._sets[name]
+        else:
+            raise FuzzyWarning("Trying to delete a regular attr, this needs extra care.")
 
 class Set:
     """
     A fuzzyset defines a 'region' within a domain.
     The associated membership function defines 'how much' a given value is
     inside this region - how 'true' the value is.
-    A set is identified by the name and attribute of its domain,
-    therefor there is no need for an extra identifier.
 
     Sets and functions MUST NOT be mixed because functions don't have
     the methods of the sets needed for the logic.
 
-    The combination operations SHOULD only be applied with sets of the same
-    domain as ranges may not overlap and thus give unexpected results,
-    however it is possible to reuse the set under different names because
-    it is simply a function that may mean different things under different
-    domains, yet have the same graph (like 'cold' could use the same function
-    as 'dry' or 'close' if the ranges are the same.)
-
     Sets that are returned from one of the operations are 'derived sets' or
     'Superfuzzysets' according to Zadeh.
     
     Note that most checks are merely assertions that can be optimized away.
     DO NOT RELY on these checks and use tests to make sure that only valid calls are made.
     """
-    def __init__(self, domain:Domain, func:callable, ops:dict=None):
+    _domain = None
+    _name = None
+    
+    def __init__(self, func:callable, *, domain=None, name=None):
+        assert callable(func)
         self.func = func
-        assert self.func is not None
-        self.ops = ops
-        assert isinstance(domain, Domain), "Must be used with a Domain."
+        # either both must be given or none
+        assert (domain is None) == (name is None)
         self.domain = domain
-        self.domain._sets.add(self)
+        self.name = name
+        
+    def name_():
+        """Name of the fuzzy set."""
+        def fget(self):
+            return self._name
+        def fset(self, value):
+            if self._name is None:
+                self._name = value 
+            else:
+                raise FuzzyWarning("Can't change name once assigned.")
+        return locals()
+    name = property(**name_())
+    del name_
+    
+    def domain_():
+        """Domain of the fuzzy set."""
+        def fget(self):
+            return self._domain
+        def fset(self, value):
+            if self._domain is None:
+                self._domain = value 
+            else:
+                # maybe could be solved by copy()?
+                raise FuzzyWarning("Can't change domain once assigned.")
+        return locals()
+    domain = property(**domain_())
+    del domain_
 
     def __call__(self, x):
-        assert self.domain.low <= x <= self.domain.high, "value outside domain"
         return self.func(x)
 
     def __invert__(self):
-        return Set(self.domain, inv(self.func))
+        return Set(inv(self.func))
 
     def __and__(self, other):
-        assert self.domain is other.domain, "Cannot combine sets of different domains."
-        return Set(self.domain, MIN(self.func, other.func))
+        return Set(MIN(self.func, other.func))
 
     def __or__(self, other):
-        assert self.domain is other.domain, "Cannot combine sets of different domains."
-        return Set(self.domain, MAX(self.func, other.func))
+        return Set(MAX(self.func, other.func))
 
     def __mul__(self, other):
-        assert self.domain is other.domain, "Cannot combine sets of different domains."
-        return Set(self.domain, product(self.func, other.func))
+        return Set(product(self.func, other.func))
 
     def __add__(self, other):
-        assert self.domain is other.domain, "Cannot combine sets of different domains."
-        return Set(self.domain, bounded_sum(self.func, other.func))
+        return Set(bounded_sum(self.func, other.func))
 
     def __pow__(self, power):
         """pow is used with hedges"""
-        return Set(self.domain, lambda x: pow(self.func(x), power))
+        return Set(lambda x: pow(self.func(x), power))
 
     def plot(self, low=None, high=None, res=None):
         """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
@@ -159,12 +184,22 @@ def plot(self, low=None, high=None, res=None):
         plt.plot(R, V)
 
     def array(self):
-        R = arange(self.domain.low, self.domain.high, self.domain.res)
         # arange may not be ideal for this
+        if self.domain is None:
+            raise FuzzyWarning("No domain assigned.")
         return fromiter((self.func(x) for x in arange(self.domain.low,
                                                      self.domain.high,
                                                      self.domain.res)), float)
 
+    def __repr__(self):
+        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}"
+
 
 class Rule:
     """
@@ -173,9 +208,9 @@ class Rule:
 
     It works like this:
     >>> temp = Domain("temperature", 0, 100)
-    >>> temp.hot = Set(temp, lambda x: 1)
+    >>> temp.hot = Set(lambda x: 1)
     >>> dist = Domain("distance", 0, 300)
-    >>> dist.close = Set(dist, lambda x: 0)
+    >>> dist.close = Set(lambda x: 0)
     
     #>>> r = Rule(min, ["distance.close", "temperature.hot"])
     #>>> d1 = temp(32)   # {'temperature.hot': 1}

fuzzy/classes.py

@@ -360,15 +360,23 @@ def bounded_sigmoid(low, high):
     k = -(4. * log(3)) / (low - high)
     # yay for limits! .. and for goddamn hidden divisions by zero thanks to floats >:/
     try:
-        o = 9 if isinf(k) else 9 * exp(low * k)
+        m = exp(low * k)
+        # possibility of an underflow! m -> 0
+        o = 9 if isinf(k) else 9 * m
+        # o can be 0!
     except OverflowError:
         o = float("inf")
 
     def f(x):
+        if o == 0 and x == float("-inf"):
+            return 1/2
         try:
+            # if o == 0 we get nan if x is -inf and k is positive
+            # then e^(inf*0) = 1
             return 0.1 if isinf(k) else 1. / (1. + exp(x * -k) * o)
         except OverflowError:
             return 0.0
+        
     return f
 
 

fuzzy/functions.py

@@ -4,52 +4,31 @@
 HEDGES
 ------
 Lingual hedges modify curves describing truthvalues.
-These work with sets only. Meta-functionality is deprecated.
+These work with sets only. It's more trouble than it is worth making
+these work with pure functions, so meta-functionality was removed.
 """
 
 from fuzzy.classes import Set
-from warnings import warn
 
 def very(g):
-    def f(x):
-        return g(x) ** 2
-
     def s_f(g):
         def f(x):
             return g(x) ** 2
         return f
-
-    if isinstance(g, Set):
-        return Set(g.domain, s_f(g.func))
-    warn("deprecated", DeprecationWarning)
-    return f
+    return Set(s_f(g.func))
 
 
 def plus(g):
-    def f(x):
-        return g(x) ** 1.25
-    
     def s_f(g):
         def f(x):
             return g(x) ** 1.25
         return f
-    
-    if isinstance(g, Set):
-        return Set(g.domain, s_f(g.func))
-    warn("deprecated", DeprecationWarning)
-    return f
+    return Set(s_f(g.func))
 
 
 def minus(g):
-    def f(x):
-        return g(x) ** 0.75
-    
     def s_f(g):
         def f(x):
             return g(x) ** 0.75
-        return f
-    
-    if isinstance(g, Set):
-        return Set(g.domain, s_f(g.func))
-    warn("deprecated", DeprecationWarning)
-    return f
+        return f 
+    return Set(s_f(g.func))

fuzzy/hedges.py

@@ -13,8 +13,8 @@ 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(self.temp, S(0, 15))
-        self.temp.hot = Set(self.temp, R(10, 20))
+        self.temp.cold = Set(S(0, 15))
+        self.temp.hot = Set(R(10, 20))
 
     def test_temp(self):
         # we need to define a dictionary-aggregation func here