Add Mamdani inference and aggregation modules

Introduces Mamdani inference engine (src/mamdani.rs), rule aggregation (src/aggregate.rs), and related test coverage. Refactors and renames src/rule.rs to src/antecedent.rs, removes src/system.rs, and updates src/lib.rs to include new modules. Enhances UniformSampler and Sampler trait, exposes Variable.terms, and adds a domain() helper. Updates Cargo.toml to add and enable the 'inference-mamdani' feature by default.

Author: JoshuaKento

Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [features]
-default  = ["f64", "ops-dyn"]
+default  = ["f64", "ops-dyn", "inference-mamdani"]
 f32      = []
 f64      = []
 serde    = ["dep:serde"]
@@ -13,6 +13,7 @@ ops-minmax = []
 ops-product = []
 ops-lukasiewicz = []
 ops-dyn = [] # enables runtime enum/trait-object API
+inference-mamdani = []
 
 [profile.release]
 debug = true

src/aggregate.rs

@@ -0,0 +1,36 @@
+//Agregation acros sets of rules
+
+use crate::{error::FuzzyError, mamdani::Rule, prelude::*, sampler, variable::Variable};
+use std::{borrow::Borrow, collections::HashMap, hash::Hash, result};
+
+pub fn elements_max(data: &mut Vec<Float>, src: &Vec<Float>) {
+    for (d, s) in data.iter_mut().zip(src) {
+        *d = d.max(*s)
+    }
+}
+
+pub fn aggregation<KI, KV>(
+    rules: Vec<Rule>,
+    input: &HashMap<KI, Float>,
+    vars: &HashMap<KV, Variable>,
+    sampler: UniformSampler,
+) -> Result<HashMap<String, Vec<Float>>>
+where
+    KI: Eq + Hash + Borrow<str>,
+    KV: Eq + Hash + Borrow<str>,
+{
+    let mut implicated_map: HashMap<String, Vec<Float>> = HashMap::new();
+    for i in 0..rules.len() {
+        let alpha = rules[i].activation(&input, &vars)?;
+        let implicated = rules[i].implicate(alpha, vars, &sampler)?;
+
+        for (k, v) in implicated {
+            implicated_map
+                .entry(k)
+                .and_modify(|cur| elements_max(cur, &v))
+                .or_insert(v);
+        }
+    }
+
+    return Ok(implicated_map);
+}

src/rule.rs renamed to src/antecedent.rs

@@ -116,13 +116,13 @@ mod tests {
         inputs.insert("temp", 7.5);
 
         // AST: (temp is hot) AND NOT (temp is cold)
-        let ast = crate::rule::Antecedent::And(
-            Box::new(crate::rule::Antecedent::Atom {
+        let ast = crate::antecedent::Antecedent::And(
+            Box::new(crate::antecedent::Antecedent::Atom {
                 var: "temp".into(),
                 term: "hot".into(),
             }),
-            Box::new(crate::rule::Antecedent::Not(Box::new(
-                crate::rule::Antecedent::Atom {
+            Box::new(crate::antecedent::Antecedent::Not(Box::new(
+                crate::antecedent::Antecedent::Atom {
                     var: "temp".into(),
                     term: "cold".into(),
                 },
@@ -134,13 +134,13 @@ mod tests {
         let cold = Triangular::new(-10.0, -5.0, 0.0).unwrap().eval(7.5);
         let expected = hot.min(1.0 - cold);
 
-        let y = crate::rule::eval_antecedent(&ast, &inputs, &vars).unwrap();
+        let y = crate::antecedent::eval_antecedent(&ast, &inputs, &vars).unwrap();
         assert!((y - expected).abs() < eps);
     }
 
     // RED: OR behavior using the same variable at a different crisp value.
     #[test]
-    fn red_antecedent_or_behavior() {
+    fn antecedent_or_behavior() {
         // Variable setup
         let mut temp = Variable::new(-10.0, 10.0).unwrap();
         temp.insert_term(
@@ -161,12 +161,12 @@ mod tests {
         inputs.insert("temp", -5.0);
 
         // AST: (temp is cold) OR (temp is hot)
-        let ast = crate::rule::Antecedent::Or(
-            Box::new(crate::rule::Antecedent::Atom {
+        let ast = crate::antecedent::Antecedent::Or(
+            Box::new(crate::antecedent::Antecedent::Atom {
                 var: "temp".into(),
                 term: "cold".into(),
             }),
-            Box::new(crate::rule::Antecedent::Atom {
+            Box::new(crate::antecedent::Antecedent::Atom {
                 var: "temp".into(),
                 term: "hot".into(),
             }),
@@ -177,7 +177,7 @@ mod tests {
         let hot = Triangular::new(0.0, 5.0, 10.0).unwrap().eval(-5.0);
         let expected = cold.max(hot);
 
-        let y = crate::rule::eval_antecedent(&ast, &inputs, &vars).unwrap();
+        let y = crate::antecedent::eval_antecedent(&ast, &inputs, &vars).unwrap();
         assert!((y - expected).abs() < crate::Float::EPSILON);
     }
 }

src/lib.rs

@@ -1,13 +1,14 @@
 pub mod membership;
 
 //Temporary Module Decleration to avoid error
+pub mod aggregate;
+pub mod antecedent;
 pub mod builder;
 pub mod defuzz;
 pub mod error;
+pub mod mamdani;
 pub mod ops;
-pub mod rule;
 pub mod sampler;
-pub mod system;
 pub mod term;
 pub mod variable;
 

src/mamdani.rs

@@ -0,0 +1,86 @@
+use std::{borrow::Borrow, collections::HashMap, hash::Hash};
+
+#[cfg(feature = "inference-mamdani")]
+use crate::sampler;
+use crate::{
+    antecedent::{Antecedent, eval_antecedent},
+    error::{FuzzyError, MissingSpace},
+    prelude::*,
+    sampler::UniformSampler,
+    variable::Variable,
+};
+
+pub enum Implication {
+    Clip,
+    Product,
+}
+
+pub struct Consequent {
+    pub var: String,
+    pub term: String,
+    //pub weight: Float,
+    //pub imp: Implication,
+}
+
+pub struct Rule {
+    pub antecedent: Antecedent,
+    pub consequent: Vec<Consequent>,
+}
+
+//Mamdani Inference Engine
+#[cfg(feature = "inference-mamdani")]
+impl Rule {
+    pub fn activation<KI, KV>(
+        &self,
+        input: &HashMap<KI, Float>,
+        vars: &HashMap<KV, Variable>,
+    ) -> Result<Float>
+    where
+        KI: Eq + Hash + Borrow<str>,
+        KV: Eq + Hash + Borrow<str>,
+    {
+        eval_antecedent(&self.antecedent, input, vars)
+    }
+
+    pub fn implicate<KV>(
+        &self,
+        alpha: Float,
+        vers: &HashMap<KV, Variable>,
+        sampler: &UniformSampler,
+    ) -> Result<HashMap<String, Vec<Float>>>
+    where
+        KV: Eq + Hash + Borrow<str>,
+    {
+        let mut result_map: HashMap<String, Vec<Float>> = HashMap::new();
+
+        for i in 0..self.consequent.len() {
+            let mut result_vec = vec![0.0; sampler.n];
+
+            let (dom_min, dom_max) = vers
+                .get(&self.consequent[i].var.as_str())
+                .ok_or(FuzzyError::NotFound {
+                    space: MissingSpace::Var,
+                    key: self.consequent[i].term.clone(),
+                })?
+                .domain();
+
+            let step = (dom_max - dom_min) / sampler.n as Float;
+
+            for k in 0..sampler.n {
+                let x = dom_min + (k as Float * step);
+                result_vec[k] = vers
+                    .get(&self.consequent[i].var.as_str())
+                    .ok_or(FuzzyError::NotFound {
+                        space: MissingSpace::Var,
+                        key: self.consequent[i].term.clone(),
+                    })?
+                    .eval(&self.consequent[i].term, x)?
+                    .min(alpha);
+            }
+
+            result_map.insert(self.consequent[i].var.to_string(), result_vec);
+        }
+        return Ok(result_map);
+        //TODO: Return type should be hashmap<string, Vec<Float>> where string signifies the variable(eg "fanspeed")
+    }
+}

src/prelude.rs

@@ -24,3 +24,6 @@ pub use crate::ops::FuzzyOps;
 
 // Term wrapper around a boxed membership function
 pub use crate::term::Term;
+
+//UniformSampling Functionality
+pub use crate::sampler::{Sampler, UniformSampler};

src/sampler.rs

@@ -1 +1,123 @@
+use crate::{Float, error::FuzzyError, prelude::*};
 
+pub trait Sampler {
+    //Trait shape: Returning Result<Vec<Float>> is fine.
+    //If you later need performance, consider an iterator or a small wrapper type, but not necessary now.
+    fn sample(&self, min: Float, max: Float) -> Result<Vec<Float>>;
+}
+
+pub struct UniformSampler {
+    pub n: usize,
+}
+
+impl Default for UniformSampler {
+    fn default() -> Self {
+        Self { n: Self::DEFAULT_N }
+    }
+}
+
+impl UniformSampler {
+    pub const DEFAULT_N: usize = 101;
+
+    pub fn new(n: usize) -> Result<Self> {
+        if n < 2 {
+            return Err(FuzzyError::OutOfBounds);
+        }
+        Ok(Self { n: n })
+    }
+}
+
+impl Sampler for UniformSampler {
+    fn sample(&self, min: Float, max: Float) -> Result<Vec<Float>> {
+        if min >= max {
+            return Err(FuzzyError::BadArity);
+        }
+
+        if !(min.is_finite() && max.is_finite()) {
+            return Err(FuzzyError::BadArity);
+        }
+
+        let n = self.n;
+        let mut sample: Vec<Float> = Vec::with_capacity(n);
+        let step = (max - min) / (n as Float - 1.0);
+
+        for i in 0..n {
+            sample.push(min + i as Float * step)
+        }
+        sample[n - 1] = max;
+
+        Ok(sample)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::Float;
+    use crate::error::FuzzyError;
+    use crate::sampler::{Sampler, UniformSampler};
+
+    #[test]
+    fn uniform_sampler_two_points_inclusive_endpoints() {
+        let s = UniformSampler::new(2).unwrap();
+        let min: Float = -3.5;
+        let max: Float = 4.5;
+        let pts = s.sample(min, max).unwrap();
+        assert_eq!(pts.len(), 2);
+        assert_eq!(pts[0], min);
+        assert_eq!(pts[1], max, "Last point must equal max for n=2");
+    }
+
+    #[test]
+    fn uniform_sampler_inclusive_endpoints_default() {
+        let s = UniformSampler::default();
+        let n = UniformSampler::DEFAULT_N;
+        let min: Float = -5.0;
+        let max: Float = 5.0;
+        let pts = s.sample(min, max).unwrap();
+        assert_eq!(pts.len(), n);
+        assert_eq!(pts.first().copied().unwrap(), min);
+        assert_eq!(
+            pts.last().copied().unwrap(),
+            max,
+            "Sampler should include max exactly"
+        );
+    }
+
+    #[test]
+    fn uniform_sampler_spacing_monotonic() {
+        let s = UniformSampler::default();
+        let min: Float = 0.0;
+        let max: Float = 10.0;
+        let pts = s.sample(min, max).unwrap();
+        assert!(pts.windows(2).all(|w| w[1] >= w[0]));
+
+        // Check approximate uniform spacing consistency across interior points
+        let eps = Float::EPSILON * 10.0;
+        let base_step = pts[1] - pts[0];
+        for i in 2..pts.len() {
+            let step = pts[i] - pts[i - 1];
+            assert!((step - base_step).abs() <= eps, "Non-uniform step at i={i}");
+        }
+    }
+
+    #[test]
+    fn uniform_sampler_invalid_points_rejected() {
+        assert!(matches!(
+            UniformSampler::new(0),
+            Err(FuzzyError::OutOfBounds)
+        ));
+        assert!(matches!(
+            UniformSampler::new(1),
+            Err(FuzzyError::OutOfBounds)
+        ));
+    }
+
+    #[test]
+    fn uniform_sampler_invalid_range_rejected() {
+        let s = UniformSampler::default();
+        // min > max must error
+        assert!(matches!(s.sample(1.0, 0.0), Err(FuzzyError::BadArity)));
+        // Degenerate range should be rejected for a sampler that requires >=2 distinct points
+        assert!(matches!(s.sample(1.0, 1.0), Err(_)));
+    }
+}

src/system.rs

@@ -13,7 +13,7 @@ pub struct Variable {
     max: Float,
 
     /// Mapping from term name to its labeled membership function wrapper.
-    terms: HashMap<String, Term>,
+    pub terms: HashMap<String, Term>,
 }
 impl Variable {
     /// Constructs a new variable, validating that `min < max`.
@@ -72,8 +72,13 @@ impl Variable {
         }
     }
 
+    /// Returns the range of domain for the membership function.(term)
+    ///
+    /// - retunrs `(min, max)`
+    pub fn domain(&self) -> (Float, Float) {
+        (self.min, self.max)
+    }
     //Optional helpers:
-    //pub fn domain(&self) -> (Float, Float)
     //pub fn names(&self) -> impl Iterator<Item=&str>
     //pub fn fuzzify(&self, x: Float) -> crate::error::Result<Vec<(String, Float)>> to get all memberships at x.
 }