Add FuzzySet Class for Triangular Fuzzy Sets

fuzzy_logic/fuzzy_operations.py

@@ -0,0 +1,162 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+""""
+ FuzzySet class for triangular fuzzy sets
+ Author: Shreya123714
+ Source: https://en.wikipedia.org/wiki/Fuzzy_set
+"""
+
+
+class FuzzySet:
+    """
+    A class for representing and
+    manipulating triangular fuzzy sets.
+
+    Attributes:
+        name (str): The name or label of the fuzzy set.
+        a (float): The left boundary of the fuzzy set.
+        b (float): The peak (central) value of the fuzzy set.
+        c (float): The right boundary of the fuzzy set.
+
+    Methods:
+        membership(x): Calculate the membership value
+        of an input 'x' in the fuzzy set.
+        union(other): Calculate the union of this fuzzy set
+        with another fuzzy set.
+        intersection(other): Calculate the intersection of this fuzzy set
+        with another fuzzy set.
+        complement(): Calculate the complement (negation)
+        of this fuzzy set.
+        plot(): Plot the membership function of the fuzzy set.
+    """
+
+    def __init__(
+        self, name: str, left_boundary: float, peak: float, right_boundary: float
+    ) -> None:
+        """
+        Initializes a triangular fuzzy set
+        with the given parameters.
+
+        Args:
+            name (str): The name or label of the fuzzy set.
+            a (float): The left boundary of the fuzzy set.
+            b (float): The peak (central) value of
+            the fuzzy set.
+            c (float): The right boundary of the fuzzy set.
+        """
+        self.name = name  # Fuzzy set name
+        self.left_boundary = left_boundary  # Left boundary
+        self.peak = peak  # Peak value
+        self.right_boundary = right_boundary  # Right boundary
+
+    def membership(self, x):
+        """
+        Calculate the membership value of
+        an input 'x' in the fuzzy set.
+
+        Args:
+            x (float): The input value for
+            which the membership is calculated.
+
+        Returns:
+            float: The membership value of 'x' in
+            the fuzzy set.
+        """
+
+        if x <= self.a or x >= self.c:
+            return 0
+        elif self.a < x <= self.b:
+            return (x - self.a) / (self.b - self.a)
+        elif self.b < x < self.c:
+            return (self.c - x) / (self.c - self.b)
+
+    def union(self, other):
+        """
+        Calculate the union of this fuzzy set
+        with another fuzzy set.
+
+        Args:
+            other (FuzzySet): Another fuzzy set
+            to union with.
+
+        Returns:
+            FuzzySet: A new fuzzy
+            set representing the union.
+        """
+
+        union_name = f"{self.name} ∪ {other.name}"
+        return FuzzySet(
+            union_name,
+            min(self.a, other.a),
+            max(self.c, other.c),
+            (self.b + other.b) / 2,
+        )
+
+    def intersection(self, other):
+        """
+        Calculate the intersection of this
+        fuzzy set with another fuzzy set.
+
+        Args:
+            other (FuzzySet): Another fuzzy set to intersect with.
+
+        Returns:
+            FuzzySet: A new fuzzy set representing the intersection.
+        """
+        intersection_name = f"{self.name} ∩ {other.name}"
+        return FuzzySet(
+            intersection_name,
+            max(self.a, other.a),
+            min(self.c, other.c),
+            (self.b + other.b) / 2,
+        )
+
+    def complement(self):
+        """
+        Calculate the complement (negation) of this fuzzy set.
+
+        Returns:
+            FuzzySet: A new fuzzy set representing the complement.
+        """
+        complement_name = f"¬{self.name}"
+        return FuzzySet(complement_name, 1 - self.c, 1 - self.a, 1 - self.b)
+
+    def plot(self):
+        """
+        Plot the membership function of the fuzzy set.
+        """
+        x = np.linspace(0, 1, 1000)
+        y = [self.membership(xi) for xi in x]
+
+        plt.plot(x, y, label=self.name)
+
+    def __str__(self):
+        return f"{self.name}: [{self.a}, {self.b}, {self.c}]"
+
+
+# Example usage:
+if __name__ == "__main__":
+    A = FuzzySet("A", 0, 0.5, 1)
+    B = FuzzySet("B", 0.2, 0.7, 1)
+
+    A.plot()
+    B.plot()
+
+    plt.xlabel("x")
+    plt.ylabel("Membership")
+    plt.legend()
+    plt.show()
+
+    union_ab = A.union(B)
+    intersection_ab = A.intersection(B)
+    complement_a = A.complement()
+
+    union_ab.plot()
+    intersection_ab.plot()
+    complement_a.plot()
+
+    plt.xlabel("x")
+    plt.ylabel("Membership")
+    plt.legend()
+    plt.show()

fuzzy_logic/test_fuzzy_logic.py

@@ -0,0 +1,47 @@
+import unittest
+from fuzzy_operations import FuzzySet
+
+class TestFuzzySet(unittest.TestCase):
+    def test_membership_within_boundaries(self):
+        A = FuzzySet("A", 0, 0.5, 1)
+
+        self.assertAlmostEqual(A.membership(0), 1.0)  # Left boundary
+        self.assertAlmostEqual(A.membership(0.25), 0.5)  # Peak value
+        self.assertAlmostEqual(A.membership(0.5), 0.0)  # Right boundary
+
+    def test_membership_outside_boundaries(self):
+        A = FuzzySet("A", 0, 0.5, 1)
+
+        self.assertAlmostEqual(A.membership(0.75), 0.0)  # Outside boundaries
+        self.assertAlmostEqual(A.membership(-0.1), 0.0)  # Outside boundaries
+
+    def test_union(self):
+        A = FuzzySet("A", 0, 0.5, 1)
+        B = FuzzySet("B", 0.2, 0.7, 1)
+
+        union_ab = A.union(B)
+
+        self.assertAlmostEqual(union_ab.membership(0.1), 1.0)  # Member of A
+        self.assertAlmostEqual(union_ab.membership(0.35), 0.5)  # Member of both A and B
+        self.assertAlmostEqual(union_ab.membership(0.75), 0.0)  # Outside boundaries
+
+    def test_intersection(self):
+        A = FuzzySet("A", 0, 0.5, 1)
+        B = FuzzySet("B", 0.2, 0.7, 1)
+
+        intersection_ab = A.intersection(B)
+
+        self.assertAlmostEqual(intersection_ab.membership(0.1), 0.0)  # Not a member of B
+        self.assertAlmostEqual(intersection_ab.membership(0.35), 0.5)  # Member of both A and B
+        self.assertAlmostEqual(intersection_ab.membership(0.75), 0.0)  # Not a member of A
+
+    def test_complement(self):
+        A = FuzzySet("A", 0, 0.5, 1)
+
+        complement_a = A.complement()
+
+        self.assertAlmostEqual(complement_a.membership(0.1), 0.0)  # Member of A
+        self.assertAlmostEqual(complement_a.membership(0.75), 1.0)  # Outside boundaries
+
+if __name__ == "__main__":
+    unittest.main()