rbfuzzymind 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 59fde5073fd561cef8896af5c5c68178d385215d10a9a46c4599ad42652cfd1b
+  data.tar.gz: 979636b8e3f11a4b2231d4d0f9eef4c5b9b05667c8523f7598806e9b9d01201a
+SHA512:
+  metadata.gz: 927c7a16cda5736b13511be75f093ab848e80265fda3d50325ca43536eaf005bf2fd34fb7f90193e758884d0f844c697e3da3c51cc5dcb0bc79c14025dc98c2d
+  data.tar.gz: 89dec6e8a795a631774035e4ba7436e842aa8ecf492ebfc58b53352d2b6f64171eeebbd60f2d857c3eb9b5a719874cdea449873eb7f60dc900bade75787a12d5

data/lib/rbfuzzymind/rbfuzzymind.rb

@@ -0,0 +1,197 @@
+
+class FuzzySet
+  attr_reader :name, :membership_function
+
+  def initialize(name, &membership_function)
+    @name = name
+    @membership_function = membership_function
+  end
+
+  def membership_degree(x)
+    membership_function.call(x)
+  end
+
+  def union(other_set)
+    FuzzySet.new("Union(#{name}, #{other_set.name})") do |x|
+      [membership_function.call(x), other_set.membership_function.call(x)].max
+    end
+  end
+
+  def intersection(other_set)
+    FuzzySet.new("Intersection(#{name}, #{other_set.name})") do |x|
+      [membership_function.call(x), other_set.membership_function.call(x)].min
+    end
+  end
+
+  def complement
+    FuzzySet.new("Complement(#{name})") do |x|
+      1 - membership_function.call(x)
+    end
+  end
+
+  def normalize
+    FuzzySet.new("Normalized(#{name})") do |x|
+      membership_function.call(x) / [1, membership_function.call(x)].max
+    end
+  end
+
+  def centroid(min_val, max_val, step = 0.01)
+    numerator = 0
+    denominator = 0
+    x = min_val
+
+    while x <= max_val
+      mu = membership_function.call(x)
+      numerator += x * mu
+      denominator += mu
+      x += step
+    end
+
+    denominator == 0 ? 0 : numerator / denominator
+  end
+end
+
+class FuzzyRule
+  attr_reader :condition, :consequence, :weight
+
+  def initialize(condition, consequence, weight = 1)
+    @condition = condition
+    @consequence = consequence
+    @weight = weight
+  end
+
+  def evaluate(inputs)
+    if condition.call(inputs)
+      result = if consequence.is_a?(FuzzySet)
+        consequence
+      elsif consequence.respond_to?(:call)
+        consequence.call(inputs)
+      else
+        consequence
+      end
+      { "result" => result, "weight" => weight }
+    else
+      nil
+    end
+  end
+end
+
+class InferenceEngine
+  def initialize(rules)
+    @rules = rules
+  end
+
+  def infer(inputs)
+    results = @rules.map do |rule|
+      rule.evaluate(inputs)
+    end.compact
+
+    aggregate_results(results)
+  end
+
+  def aggregate_results(results)
+    return 'Low Priority' if results.empty?
+
+    total_weight = 0
+    weighted_sum = 0
+
+    results.each do |result|
+      weighted_sum += priority_mapping(result['result']) * result['weight']
+      total_weight += result['weight']
+    end
+
+    if total_weight > 0
+      reverse_priority_mapping(weighted_sum / total_weight)
+    else
+      'Low Priority'
+    end
+  end
+
+  def priority_mapping(priority)
+    { 'Urgent' => 3, 'High Priority' => 2, 'Medium Priority' => 1 }.fetch(priority, 0)
+  end
+
+  def reverse_priority_mapping(score)
+    case score
+    when 2.5..Float::INFINITY
+      'Urgent'
+    when 1.5...2.5
+      'High Priority'
+    when 0.5...1.5
+      'Medium Priority'
+    else
+      'Low Priority'
+    end
+  end
+
+  def get_fuzzy_set_consequences
+    @rules.select { |rule| rule.consequence.is_a?(FuzzySet) }.map(&:consequence)
+  end
+
+  def defuzzify_centroid(min_val, max_val, step = 0.01)
+    numerator = 0
+    denominator = 0
+    fuzzy_sets = get_fuzzy_set_consequences
+    x = min_val
+
+    while x <= max_val
+      mu = fuzzy_sets.map { |fs| fs.membership_degree(x) || 0 }.max || 0
+      numerator += x * mu
+      denominator += mu
+      x += step
+    end
+
+    denominator == 0 ? 0 : numerator / denominator
+  end
+
+
+  def defuzzify_mom(min_val, max_val, step = 0.01)
+    max_mu = 0
+    sum_x = 0
+    count = 0
+    fuzzy_sets = get_fuzzy_set_consequences
+    x = min_val
+
+    while x <= max_val
+      mu = fuzzy_sets.map { |fs| fs.membership_degree(x) }.max
+      if mu > max_mu
+        max_mu = mu
+        sum_x = x
+        count = 1
+      elsif mu == max_mu
+        sum_x += x
+        count += 1
+      end
+      x += step
+    end
+
+    count == 0 ? 0 : sum_x / count
+  end
+
+  def defuzzify_bisector(min_val, max_val, step = 0.01)
+    total_area = 0
+    left_area = 0
+    bisector = min_val
+    fuzzy_sets = get_fuzzy_set_consequences
+    x = min_val
+
+    while x <= max_val
+      mu = fuzzy_sets.map { |fs| fs.membership_degree(x) }.max
+      total_area += mu * step
+      x += step
+    end
+
+    x = min_val
+    while x <= max_val
+      mu = fuzzy_sets.map { |fs| fs.membership_degree(x) }.max
+      left_area += mu * step
+      if left_area >= total_area / 2
+        bisector = x
+        break
+      end
+      x += step
+    end
+
+    bisector
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: rbfuzzymind
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- fadedreams7
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-08-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: rbfuzzymind is a Ruby gem that provides a comprehensive suite for implementing
+  fuzzy logic systems. It includes classes for fuzzy sets, fuzzy rules, and inference
+  engines, enabling the development of complex decision-making systems based on fuzzy
+  logic principles. Key features include membership function operations (union, intersection,
+  complement, normalization), rule evaluation, and defuzzification methods (centroid,
+  mean of maxima, and bisector). Designed for flexibility and extensibility, rbfuzzymind
+  helps developers build robust and adaptable systems for handling uncertainty and
+  imprecision in various applications.
+email:
+- fadedreams7@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rbfuzzymind/rbfuzzymind.rb
+homepage: https://github.com/fadedreams/rbfuzzymind
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.17
+signing_key:
+specification_version: 4
+summary: A Ruby gem for fuzzy logic systems and inference engines.
+test_files: []