Add fuzzy logic operator families and rule evaluation

Introduces the `FuzzyOps` trait and multiple operator families (MinMax, Product, Łukasiewicz) with feature flags for fuzzy logic operations. Adds the `Antecedent` AST and `eval_antecedent` function for rule evaluation using the default Min–Max operators. Updates error handling to support missing variable/input spaces, and re-exports `FuzzyOps` in the prelude.

Author: JoshuaKento

Cargo.toml

@@ -4,11 +4,18 @@ version = "0.1.0"
 edition = "2024"
 
 [features]
-default  = ["f64"]
+default  = ["f64", "ops-dyn"]
 f32      = []
 f64      = []
 serde    = ["dep:serde"]
 parallel = ["dep:rayon"]
+ops-minmax = []
+ops-product = []
+ops-lukasiewicz = []
+ops-dyn = [] # enables runtime enum/trait-object API
+
+[profile.release]
+debug = true
 
 [dependencies]
 serde = { version = "1", features = ["derive"], optional = true }

src/error.rs

@@ -7,13 +7,19 @@ pub type Result<T> = std::result::Result<T, FuzzyError>;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[non_exhaustive]
-
 ///Basic errors that can occur in the rust-fuzzylogic library
 pub enum FuzzyError {
     BadArity,
     EmptyInput,
     TypeMismatch,
     OutOfBounds,
+    NotFound { space: MissingSpace, key: String },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum MissingSpace {
+    Var,
+    Input,
 }
 
 impl fmt::Display for FuzzyError {
@@ -31,6 +37,16 @@ impl fmt::Display for FuzzyError {
             FuzzyError::OutOfBounds => {
                 write!(f, "Out of bounds")
             }
+            FuzzyError::NotFound { space, key } => {
+                write!(
+                    f,
+                    "Keys not found. {key} cannot be found in {}",
+                    match space {
+                        MissingSpace::Input => "Inputs",
+                        MissingSpace::Var => "Vars",
+                    }
+                )
+            }
         }
     }
 }

src/ops.rs

@@ -1 +1,164 @@
+// Operators for fuzzy logic antecedents and inference.
+// Provides a trait (`FuzzyOps`) and concrete families (`Ops`) implementing AND/OR/NOT.
+use crate::Float;
 
+/// Common interface for fuzzy logic operators (T-norm, S-norm, complement).
+pub trait FuzzyOps {
+    /// T-norm (logical AND) combining two degrees in [0, 1].
+    fn t(&self, a: Float, b: Float) -> Float;
+
+    /// S-norm (logical OR) combining two degrees in [0, 1].
+    fn s(&self, a: Float, b: Float) -> Float;
+
+    /// Complement (logical NOT) of a degree in [0, 1].
+    fn c(&self, a: Float) -> Float;
+}
+
+#[cfg(feature = "ops-minmax")]
+pub struct MinMax;
+#[cfg(feature = "ops-minmax")]
+impl FuzzyOps for MinMax {
+    fn t(&self, a: Float, b: Float) -> Float {
+        a.min(b)
+    }
+
+    fn s(&self, a: Float, b: Float) -> Float {
+        a.max(b)
+    }
+
+    fn c(&self, a: Float) -> Float {
+        1.0 - a
+    }
+}
+
+#[cfg(feature = "ops-product")]
+pub struct MinMax;
+#[cfg(feature = "ops-product")]
+impl FuzzyOps for MinMax {
+    fn t(&self, a: Float, b: Float) -> Float {
+        a * b
+    }
+
+    fn s(&self, a: Float, b: Float) -> Float {
+        a + b - a * b
+    }
+
+    fn c(&self, a: Float) -> Float {
+        1.0 - a
+    }
+}
+
+#[cfg(feature = "ops-lukasiewicz")]
+pub struct MinMax;
+#[cfg(feature = "ops-lukasiewicz")]
+impl FuzzyOps for MinMax {
+    fn t(&self, a: Float, b: Float) -> Float {
+        (a + b - 1.0).max(0.0)
+    }
+
+    fn s(&self, a: Float, b: Float) -> Float {
+        (a + b).min(1.0)
+    }
+
+    fn c(&self, a: Float) -> Float {
+        1.0 - a
+    }
+}
+
+#[cfg(feature = "ops-dyn")]
+#[derive(Clone, Copy, Debug)]
+/// Built-in operator families providing AND/OR/NOT over degrees.
+pub enum Ops {
+    /// Min–Max family
+    /// - T: `min(a, b)`
+    /// - S: `max(a, b)`
+    /// - C: `1 - a`
+    MinMax,
+    /// Product family
+    /// - T: `a * b`
+    /// - S: `a + b - a * b` (not algebraic sum; may exceed 1.0)
+    /// - C: `1 - a`
+    Product,
+    /// Łukasiewicz family
+    /// - T: `max(0, a + b - 1)`
+    /// - S: `min(1, a + b)`
+    /// - C: `1 - a`
+    Lukasiewicz,
+}
+#[cfg(feature = "ops-dyn")]
+/// Implements `FuzzyOps` for each `Ops` variant using the formulas above.
+impl FuzzyOps for Ops {
+    /// T-norm (AND) per family.
+    fn t(&self, a: Float, b: Float) -> Float {
+        match self {
+            Ops::MinMax => a.min(b),
+            Ops::Product => a * b,
+            Ops::Lukasiewicz => (a + b - 1.0).max(0.0),
+        }
+    }
+
+    /// S-norm (OR) per family.
+    fn s(&self, a: Float, b: Float) -> Float {
+        match self {
+            Ops::MinMax => a.max(b),
+            Ops::Product => a + b - a * b,
+            Ops::Lukasiewicz => (a + b).min(1.0),
+        }
+    }
+
+    /// Complement (NOT) shared by all families: `1 - a`.
+    fn c(&self, a: Float) -> Float {
+        1.0 - a
+    }
+}
+
+#[cfg(feature = "ops-dyn")]
+#[cfg(test)]
+mod tests_dyn_ops {
+    use crate::ops::*;
+
+    // RED: expected default operator behavior (min/max/1-x).
+    // This test references the intended API and should fail right now
+    // because the operators are not implemented yet.
+    #[test]
+    fn red_minmax_defaults_and_or_not() {
+        let v = crate::ops::Ops::MinMax;
+
+        // Mixed values
+        assert_eq!(v.t(0.2, 0.8), 0.2);
+        assert_eq!(v.s(0.2, 0.8), 0.8);
+        assert_eq!(v.c(0.2), 0.8);
+
+        // Boundaries
+        assert_eq!(v.t(0.0, 1.0), 0.0);
+        assert_eq!(v.s(0.0, 1.0), 1.0);
+        assert_eq!(v.c(0.0), 1.0);
+        assert_eq!(v.c(1.0), 0.0);
+    }
+
+    #[test]
+    fn product_ops_and_or_not_matches_code() {
+        let v = Ops::Product;
+        let eps = crate::Float::EPSILON;
+        // t = a*b
+        assert!((v.t(0.2, 0.8) - 0.16).abs() < eps);
+        // s = a + b (per current code)
+        assert!((v.s(0.1, 0.2) - 0.28).abs() < eps);
+        // c = 1 - a
+        assert!((v.c(0.2) - 0.8).abs() < eps);
+    }
+
+    #[test]
+    fn lukasiewicz_ops_and_or_not_matches_code() {
+        let v = Ops::Lukasiewicz;
+        let eps = crate::Float::EPSILON;
+        // t = max(0, a + b - 1)
+        assert!((v.t(0.2, 0.8) - 0.0).abs() < eps);
+        assert!((v.t(0.8, 0.3) - 0.1).abs() < eps);
+        // s = min(1, a + b)
+        assert!((v.s(0.2, 0.8) - 1.0).abs() < eps);
+        assert!((v.s(0.4, 0.4) - 0.8).abs() < eps);
+        // c = 1 - a
+        assert!((v.c(0.2) - 0.8).abs() < eps);
+    }
+}

src/prelude.rs

@@ -19,5 +19,8 @@ pub use crate::membership::MembershipFn;
 pub use crate::membership::trapezoidal::Trapezoidal;
 pub use crate::membership::{Gaussian, Triangular};
 
+// Fuzzy Set Operands
+pub use crate::ops::FuzzyOps;
+
 // Term wrapper around a boxed membership function
 pub use crate::term::Term;