Rename adjective to term

Author: jsexauer

skfuzzy/control/antecedent_consequent.py

@@ -86,13 +86,13 @@ def set_patch(self, label, cut):
             Floating-point value from 0 to 1 calculated from current inputs
             via a fuzzy rule.
         """
-        if self.adjectives[label].membership_value is None:
-            self.adjectives[label].membership_value = cut
-        elif self.adjectives[label].membership_value < cut:
+        if self.terms[label].membership_value is None:
+            self.terms[label].membership_value = cut
+        elif self.terms[label].membership_value < cut:
             # Update existing cut using an accumulation method
             #  (this is assuming ACCU = max)
             # TODO: Multiple accumulation methods
-            self.adjectives[label].membership_value = cut
+            self.terms[label].membership_value = cut
 
 
 class Intermediary(FuzzyVariable):
@@ -103,17 +103,17 @@ def __init__(self, universe, label):
 
     def set_patch(self, label, cut):
         ### Consequent mocking
-        if self.adjectives[label].membership_value is None:
-            self.adjectives[label].membership_value = cut
-        elif self.adjectives[label].membership_value < cut:
+        if self.terms[label].membership_value is None:
+            self.terms[label].membership_value = cut
+        elif self.terms[label].membership_value < cut:
             # Update existing cut using an accumulation method
             #  (this is assuming ACCU = max)
             # TODO: Multiple accumulation methods
-            self.adjectives[label].membership_value = cut
+            self.terms[label].membership_value = cut
 
         # Update my crisp value given this new patch
         output_mf, cut_mfs = self._find_crisp_value()
         assert len(cut_mfs) > 0
-        crisp = defuzz(self.universe, output_mf, self.defuzzy_method)
+        crisp = defuzz(self.universe, output_mf, self.defuzzify_method)
         self.crisp_value = crisp
         print "%s is now %s" % (self, crisp)

skfuzzy/control/controlsystem.py

@@ -6,7 +6,7 @@
 import networkx as nx
 import matplotlib.pylab as plt
 from .antecedent_consequent import Antecedent, Consequent, Intermediary
-from .fuzzyvariable import FuzzyVariable, FuzzyVariableAdjective
+from .fuzzyvariable import FuzzyVariable, FuzzyVariableTerm
 from .visualization import ControlSystemVisualizer
 
 try:
@@ -51,9 +51,6 @@ def __init__(self, antecedents=None, consequents=None, kind='or',
         self.collected_firing = {}
         self.final_firing = None
 
-        if self.label is None:
-            self.label = "Rule %d" % self._id
-
         if antecedents is None or consequents is None:
             self.connections = None
         else:
@@ -63,6 +60,8 @@ def __repr__(self):
         """
         Print a concise, readable summary of the fuzzy rule.
         """
+        if self.label is not None:
+            return self.label
         # All this for a pretty printed representation of the rule...
         antlen = len(self.antecedents)
         conlen = len(self.consequents)
@@ -93,23 +92,23 @@ def _chk_obj(self, var, obj):
         Argument checking to ensure every adjective's parent is type ``obj``.
         """
         temp = self._iter(var)
-        for adj in temp:
-            parent = adj.parent_variable
-            if not isinstance(adj, FuzzyVariableAdjective):
-                raise ValueError("All elements must be adjectives")
+        for term in temp:
+            parent = term.parent_variable
+            if not isinstance(term, FuzzyVariableTerm):
+                raise ValueError("All elements must be terms")
             if parent is None:
-                raise ValueError("All adjectives must have a parent")
+                raise ValueError("All terms must have a parent")
             if not isinstance(parent, obj) and \
                not isinstance(parent, Intermediary):
-                raise ValueError("All adjective's variables must be of type "
+                raise ValueError("All term's variables must be of type "
                                  "{0}".format(obj))
         return temp
 
     def _iter(self, var):
         """
         Ensure a variable is iterable; wrap in a list if necessary.
         """
-        if issubclass(var.__class__, FuzzyVariableAdjective):
+        if issubclass(var.__class__, FuzzyVariableTerm):
             return [var, ]
         else:
             return var
@@ -124,30 +123,30 @@ def _chk_kind(self, string):
         else:
             raise ValueError("Incorrect kind. Options are 'or' or 'and'.")
 
-    def add_antecedent(self, antecedent_adj):
+    def add_antecedent(self, antecedent_term):
         """
         Populate the graph with a new antecedent, connecting it to this rule.
         """
-        assert isinstance(antecedent_adj, FuzzyVariableAdjective)
-        antecedent = antecedent_adj.parent_variable
+        assert isinstance(antecedent_term, FuzzyVariableTerm)
+        antecedent = antecedent_term.parent_variable
         assert isinstance(antecedent, Antecedent) or isinstance(antecedent, Intermediary)
 
-        # Antecedent -> Antecedent_Adj -> Rule
-        self.graph.add_path([antecedent, antecedent_adj])
-        self.graph.add_path([antecedent_adj, self])
+        # Antecedent -> Antecedent_Term -> Rule
+        self.graph.add_path([antecedent, antecedent_term])
+        self.graph.add_path([antecedent_term, self])
 
 
-    def add_consequent(self, consequent_adj):
+    def add_consequent(self, consequent_term):
         """
         Populate the graph with a new consequent, connecting it to this rule.
         """
-        assert isinstance(consequent_adj, FuzzyVariableAdjective)
-        consequent = consequent_adj.parent_variable
+        assert isinstance(consequent_term, FuzzyVariableTerm)
+        consequent = consequent_term.parent_variable
         assert isinstance(consequent, Consequent) or isinstance(consequent, Intermediary)
 
-        # Rule -> Consequent_Adjective -> Consequent
-        self.graph.add_path([self, consequent_adj])
-        self.graph.add_path([consequent_adj, consequent])
+        # Rule -> Consequent_Term -> Consequent
+        self.graph.add_path([self, consequent_term])
+        self.graph.add_path([consequent_term, consequent])
 
 
 
@@ -168,12 +167,12 @@ def compute(self):
 
         # Collect the firing of all input membership functions
         self.collected_firing = {}
-        for antecedent_adj in self.graph.predecessors(self):
-            mv = antecedent_adj.membership_value
+        for antecedent_term in self.graph.predecessors(self):
+            mv = antecedent_term.membership_value
             if mv is None:
                 raise Exception("Membership value missing for " +
-                                antecedent_adj.full_label)
-            self.collected_firing[antecedent_adj.full_label] = mv
+                                antecedent_term.full_label)
+            self.collected_firing[antecedent_term.full_label] = mv
 
         # Combine membership function firing as appropriate for this rule
         if self.kind == 'or':
@@ -184,9 +183,9 @@ def compute(self):
             raise NotImplementedError("Unexpected kind: " + self.kind)
 
         # Cap output membership function(s) in consequents
-        for consequent_adj in self.graph.successors(self):
-            consequent_adj.parent_variable.set_patch(
-                consequent_adj.label, self.final_firing)
+        for consequent_term in self.graph.successors(self):
+            consequent_term.parent_variable.set_patch(
+                consequent_term.label, self.final_firing)
 
     def view(self):
         ControlSystemVisualizer(self).view().show()
@@ -336,8 +335,8 @@ def print_state(self):
         print "==========="
         for v in self.fuzzy_variables:
             print "{0:<25} = {1}".format(v, v.crisp_value)
-            for adj in v.adjectives.values():
-                print "  - {0:<22}: {1}".format(adj.label, adj.membership_value)
+            for term in v.terms.values():
+                print "  - {0:<22}: {1}".format(term.label, term.membership_value)
         print ""
         print "======="
         print " Rules "

skfuzzy/control/fuzzyvariable.py

@@ -14,11 +14,11 @@
     from .ordereddict import OrderedDict
 
 
-class FuzzyVariableAdjective(object):
+class FuzzyVariableTerm(object):
     """
-    An adjective and associated member function for a fuzzy varaible.
+    An term and associated member function for a fuzzy varaible.
     For example, if one were creating a FuzzyVariable with a simple three-point
-    liker scale, three `FuzzyVariableAdjective` would be created: poor, average,
+    liker scale, three `FuzzyVariableTerm` would be created: poor, average,
     and good.
     """
 
@@ -31,9 +31,9 @@ def __init__(self, label, membership_function):
 
     @property
     def full_label(self):
-        """Adjective with parent.  Ex: velocity['fast']"""
+        """Term with parent.  Ex: velocity['fast']"""
         if self.parent_variable is None:
-            raise ValueError("This adjective must be bound to a parent first")
+            raise ValueError("This term must be bound to a parent first")
         return self.parent_variable.label + "[" + self.label + "]"
 
     def __repr__(self):
@@ -69,7 +69,7 @@ class FuzzyVariable(object):
     This class is designed as the base class underlying the Antecedent and
     Consequent classes, not for individual use.
     """
-    def __init__(self, universe, label, defuzzy_method='centroid'):
+    def __init__(self, universe, label, defuzzify_method='centroid'):
         """
         Initialization of fuzzy variable
 
@@ -83,8 +83,8 @@ def __init__(self, universe, label, defuzzy_method='centroid'):
         """
         self.universe = np.asarray(universe)
         self.label = label
-        self.defuzzy_method = defuzzy_method
-        self.adjectives = OrderedDict()
+        self.defuzzify_method = defuzzify_method
+        self.terms = OrderedDict()
 
         self._id = id(self)
         self._crisp_value_accessed = False
@@ -94,17 +94,17 @@ def __init__(self, var):
                 self.var = var
 
             def __getitem__(self, key):
-                # Get the positive version of the adjective
+                # Get the positive version of the term
                 lbl = "NOT-" + key
-                if lbl in self.var.adjectives.keys():
+                if lbl in self.var.terms.keys():
                     return self.var[lbl]
 
-                posadj = self.var[key]
-                negadj = FuzzyVariableAdjective(lbl, 1. - posadj.mf)
-                if posadj.membership_value is not None:
-                    negadj.membership_value = 1. - posadj.membership_value
-                self.var[lbl] = negadj
-                return negadj
+                posterm = self.var[key]
+                negterm = FuzzyVariableTerm(lbl, 1. - posterm.mf)
+                if posterm.membership_value is not None:
+                    negterm.membership_value = 1. - posterm.membership_value
+                self.var[lbl] = negterm
+                return negterm
         self.not_ = _NotGenerator(self)
 
     def __repr__(self):
@@ -115,17 +115,17 @@ def __len__(self):
 
     def __getitem__(self, key):
         """
-        Calling variable['label'] will activate 'label' membership function.
+        Calling variable['label'] will return the 'label' term
         """
-        if key in self.adjectives.keys():
-            return self.adjectives[key]
+        if key in self.terms.keys():
+            return self.terms[key]
         else:
             # Build a pretty list of available mf labels and raise an
             # informative error message
             options = ''
-            i0 = len(self.adjectives) - 1
-            i1 = len(self.adjectives) - 2
-            for i, available_key in enumerate(self.adjectives.keys()):
+            i0 = len(self.terms) - 1
+            i1 = len(self.terms) - 2
+            for i, available_key in enumerate(self.terms.keys()):
                 if i == i1:
                     options += "'" + str(available_key) + "', or "
                 elif i == i0:
@@ -139,19 +139,20 @@ def __getitem__(self, key):
 
     def __setitem__(self, key, item):
         """
-        Enables new membership functions or adjectives to be added with the
+        Enables new membership functions or term to be added with the
         syntax::
 
           variable['new_label'] = new_mf
         """
-        if isinstance(item, FuzzyVariableAdjective):
+        if isinstance(item, FuzzyVariableTerm):
             if item.label != key:
-                raise ValueError("Adjective's label must match new key")
+                raise ValueError("Term's label must match new key")
             if item.parent_variable is not None:
-                raise ValueError("Adjective must not already have a parent")
+                raise ValueError("Term must not already have a parent")
         else:
-            # Try to create an adjective
-            item = FuzzyVariableAdjective(key, np.asarray(item))
+            # Try to create a term from item, assuming it is a membership
+            # function
+            item = FuzzyVariableTerm(key, np.asarray(item))
 
         if self._crisp_value_accessed:
             # TODO: Overcome this limitation
@@ -172,45 +173,45 @@ def __setitem__(self, key, item):
 
         # If above pass, add the new membership function
         item.parent_variable = self
-        self.adjectives[key] = item
+        self.terms[key] = item
 
     @property
     def crisp_value(self):
         """Derive crisp value based on membership of adjectives"""
         output_mf, cut_mfs = self._find_crisp_value()
         if len(cut_mfs) == 0:
-            raise ValueError("No adjectives have memberships.  Make sure you "
+            raise ValueError("No terms have memberships.  Make sure you "
                              "have at least one rule connected to this "
                              "variable and have run the rules calculation.")
         self._crisp_value_accessed = True
-        return defuzz(self.universe, output_mf, self.defuzzy_method)
+        return defuzz(self.universe, output_mf, self.defuzzify_method)
 
     @crisp_value.setter
     def crisp_value(self, value):
         """Propagate crisp value down to adjectives by calculating membership"""
-        if len(self.adjectives) == 0:
-            raise ValueError("Set Adjective membership function(s) first")
+        if len(self.terms) == 0:
+            raise ValueError("Set Term membership function(s) first")
 
-        for label, adj in self.adjectives.items():
+        for label, adj in self.terms.items():
             adj.membership_value = \
                                 interp_membership(self.universe, adj.mf, value)
         self._crisp_value_accessed = True
 
     def _find_crisp_value(self):
         # Check we have some adjectives
-        if len(self.adjectives.keys()) == 0:
-            raise ValueError("Set Adjective membership function(s) first")
+        if len(self.terms.keys()) == 0:
+            raise ValueError("Set term membership function(s) first")
 
         # Initilize membership
         output_mf = np.zeros_like(self.universe, dtype=np.float64)
 
         # Build output membership function
         cut_mfs = {}
-        for label, adj in self.adjectives.items():
-            cut = adj.membership_value
+        for label, term in self.terms.items():
+            cut = term.membership_value
             if cut is None:
                 continue # No membership defined for this adjective
-            cut_mfs[label] = np.minimum(cut, adj.mf)
+            cut_mfs[label] = np.minimum(cut, term.mf)
             np.maximum(output_mf, cut_mfs[label], output_mf)
 
         return output_mf, cut_mfs
@@ -316,7 +317,7 @@ def automf(self, number=5, variable_type='quality', names=None,
         abcs = [[c - w / 2, c, c + w / 2] for c, w in zip(centers, widths)]
 
         # Clear existing adjectives, if any
-        self.adjectives = OrderedDict()
+        self.terms = OrderedDict()
 
         # Repopulate
         for name, abc in zip(names, abcs):

skfuzzy/control/visualization.py

@@ -51,7 +51,7 @@ def view(self, *args, **kwargs):
         # Plot defuzzified output if available
         if len(cut_mfs) > 0:
             crip_value = defuzz(self.fuzzy_var.universe, output_mf,
-                                self.fuzzy_var.defuzzy_method)
+                                self.fuzzy_var.defuzzify_method)
             if crip_value is not None:
                 y = interp_membership(self.fuzzy_var.universe,
                                       output_mf, crip_value)
@@ -67,9 +67,9 @@ def _init_plot(self):
                      self.fuzzy_var.universe.max()])
 
         # Make the plots
-        for key, adj in self.fuzzy_var.adjectives.items():
+        for key, term in self.fuzzy_var.terms.items():
             self.plots[key] = self.ax.plot(self.fuzzy_var.universe,
-                                             adj.mf,
+                                             term.mf,
                                              label=key,
                                              lw=1)