Merge pull request #3 from JoshuaKento/main

fundamental logic fixes, prepared crate metadata for publication

Author: JoshuaKento

Cargo.toml

@@ -11,6 +11,7 @@ readme = "README.md"
 keywords = ["fuzzy", "logic", "ai", "inference"]
 categories = ["algorithms", "science"]
 rust-version = "1.74"
+ exclude = ["target/**"]
 
 [features]
 default  = ["f64", "ops-dyn", "inference-mamdani"]

src/aggregate.rs

@@ -12,10 +12,10 @@ pub fn elements_max(data: &mut Vec<Float>, src: &Vec<Float>) {
 
 /// Aggregate the contributions of all rules into output membership functions.
 pub fn aggregation<KI, KV>(
-    rules: Vec<Rule>,
+    rules: &[Rule],
     input: &HashMap<KI, Float>,
     vars: &HashMap<KV, Variable>,
-    sampler: UniformSampler,
+    sampler: &UniformSampler,
 ) -> Result<HashMap<String, Vec<Float>>>
 where
     KI: Eq + Hash + Borrow<str>,

src/defuzz.rs

@@ -4,27 +4,27 @@ use std::{borrow::Borrow, collections::HashMap, hash::Hash};
 
 /// Defuzzify aggregated membership samples using the centroid of area method.
 pub fn defuzzification<KV>(
-    myu: HashMap<String, Vec<Float>>,
+    agg_memberships: &HashMap<String, Vec<Float>>,
     vars: &HashMap<KV, Variable>,
 ) -> Result<HashMap<String, Float>>
 where
     KV: Eq + Hash + Borrow<str>,
 {
     let mut result_map: HashMap<String, Float> = HashMap::new();
-    for (i, j) in myu {
+    for (i, j) in agg_memberships {
         let num = j.len();
         let (var_min, var_max) = vars.get(&i).ok_or(FuzzyError::EmptyInput)?.domain();
         let step = (var_max - var_min) / (num as Float - 1.0);
 
-        let (mut sum_myux, mut sum_myu): (Float, Float) = (0.0, 0.0);
+        let (mut sum_agg_memberships_x, mut sum_agg_memberships): (Float, Float) = (0.0, 0.0);
         let mut l: usize = 0;
         for k in j {
             let x = var_min + step * l as Float;
-            sum_myux = sum_myux + (x * k);
-            sum_myu = sum_myu + k;
+            sum_agg_memberships_x = sum_agg_memberships_x + (x * k);
+            sum_agg_memberships = sum_agg_memberships + k;
             l += 1;
         }
-        result_map.insert(i, sum_myux / sum_myu);
+        result_map.insert(i.to_string(), sum_agg_memberships_x / sum_agg_memberships);
     }
 
     return Ok(result_map);

src/rulespace.rs

@@ -3,7 +3,7 @@ use std::{borrow::Borrow, collections::HashMap, hash::Hash};
 use crate::{
     aggregate::aggregation,
     defuzz::defuzzification,
-    error::{self},
+    error::{self, FuzzyError},
     mamdani::Rule,
     sampler::UniformSampler,
     variable::Variable,
@@ -13,53 +13,57 @@ use crate::{
 // Container for fuzzy variables, rules, and intermediate membership data.
 pub struct RuleSpace {
     pub vars: HashMap<String, Variable>,
-    pub myu: HashMap<String, Vec<Float>>,
+    pub agg_memberships: HashMap<String, Vec<Float>>,
     pub rules: Vec<Rule>,
 }
 
 impl RuleSpace {
     /// Create a rule space with the supplied variables and rules.
-    pub fn new(self, vars: HashMap<String, Variable>, rules: Vec<Rule>) -> Self {
-        return Self {
-            vars: vars,
-            myu: HashMap::new(),
-            rules: rules,
-        };
+    pub fn new(vars: HashMap<String, Variable>, rules: Vec<Rule>) -> error::Result<Self> {
+        if vars.is_empty() || rules.is_empty() {
+            return Err(FuzzyError::EmptyInput);
+        } else {
+            return Ok(Self {
+                vars: vars,
+                agg_memberships: HashMap::new(),
+                rules: rules,
+            });
+        }
     }
 
     /// Append additional rules to the existing rule set.
-    pub fn add_rules(mut self, rules: &mut Vec<Rule>) {
+    pub fn add_rules(&mut self, rules: &mut Vec<Rule>) {
         self.rules.append(rules);
     }
 
     /// Run the aggregation step for all rules with the provided crisp inputs.
     pub fn aggregate<KI>(
         &mut self,
         input: &HashMap<KI, Float>,
-        sampler: UniformSampler,
+        sampler: &UniformSampler,
     ) -> error::Result<()>
     where
         KI: Eq + Hash + Borrow<str>,
     {
-        let rules = std::mem::take(&mut self.rules);
-        let myu = aggregation(rules, input, &self.vars, sampler)?;
-        self.myu = myu;
+        //let rules = std::mem::take(&mut self.rules);
+        let agg_memberships = aggregation(&self.rules, input, &self.vars, sampler)?;
+        self.agg_memberships = agg_memberships;
 
         Ok(())
     }
 
     /// Aggregate and then defuzzify each output variable using the supplied sampler.
-    pub fn defuzzificate<KI>(
+    pub fn defuzzify<KI>(
         &mut self,
         input: &HashMap<KI, Float>,
-        sampler: UniformSampler,
-    ) -> crate::error::Result<HashMap<String, Float>>
+        sampler: &UniformSampler,
+    ) -> error::Result<HashMap<String, Float>>
     where
         KI: Eq + Hash + Borrow<str>,
     {
-        let _ = self.aggregate(input, sampler);
-        let myu = std::mem::take(&mut self.myu);
-        Ok(defuzzification(myu, &self.vars)?)
+        let _ = self.aggregate(input, sampler)?;
+        //let agg_memberships = std::mem::take(&mut self.agg_memberships);
+        Ok(defuzzification(&self.agg_memberships, &self.vars)?)
     }
     //is there a nessecity?
     //pub fn consequent_keys() {}

target/.rustc_info.json

@@ -0,0 +1 @@
+{"rustc_fingerprint":4715693574508695924,"outputs":{"7971740275564407648":{"success":true,"status":"","code":0,"stdout":"___.exe\nlib___.rlib\n___.dll\n___.dll\n___.lib\n___.dll\nC:\\Users\\Joshua\\.rustup\\toolchains\\stable-x86_64-pc-windows-msvc\npacked\n___\ndebug_assertions\npanic=\"unwind\"\nproc_macro\ntarget_abi=\"\"\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"msvc\"\ntarget_family=\"windows\"\ntarget_feature=\"cmpxchg16b\"\ntarget_feature=\"fxsr\"\ntarget_feature=\"sse\"\ntarget_feature=\"sse2\"\ntarget_feature=\"sse3\"\ntarget_has_atomic=\"128\"\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_os=\"windows\"\ntarget_pointer_width=\"64\"\ntarget_vendor=\"pc\"\nwindows\n","stderr":""},"17747080675513052775":{"success":true,"status":"","code":0,"stdout":"rustc 1.89.0 (29483883e 2025-08-04)\nbinary: rustc\ncommit-hash: 29483883eed69d5fb4db01964cdf2af4d86e9cb2\ncommit-date: 2025-08-04\nhost: x86_64-pc-windows-msvc\nrelease: 1.89.0\nLLVM version: 20.1.7\n","stderr":""}},"successes":{}}

target/.rustdoc_fingerprint.json

@@ -0,0 +1 @@
+{"rustc_vv":"rustc 1.89.0 (29483883e 2025-08-04)\nbinary: rustc\ncommit-hash: 29483883eed69d5fb4db01964cdf2af4d86e9cb2\ncommit-date: 2025-08-04\nhost: x86_64-pc-windows-msvc\nrelease: 1.89.0\nLLVM version: 20.1.7\n"}

target/CACHEDIR.TAG

@@ -0,0 +1,3 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by cargo.
+# For information about cache directory tags see https://bford.info/cachedir/

target/debug/.cargo-lock

@@ -0,0 +1 @@
+This file has an mtime of when this was started.