fuzzy_associative_memory 1.2.0 → 1.3.0

data/CHANGELOG.md

@@ -1,11 +1,14 @@
 # Changelog for fuzzy-associative-memory
 
-## 1.2, 23 August 2013
+## 1.3.0, 2 September 2013
+* Massive performance and efficiency effort. This version of the Gem clocks in at 3.5x the speed of my 1.1 series in synthetic benchmarks. If you use the FAM in a tight loop, this will help a lot.
+
+## 1.2.0, 23 August 2013
 * RuleSet::calculate() gets a refactor / efficiency rewrite
 * Argument sanity-checking
 * Improvements to Gnuplot visualization (logarithmic axis, return filename to caller)
 
-## 1.1, 26 July 2013
+## 1.1.0, 26 July 2013
 * Fuzzy Linguistic Variables are hard to visualize, especially when they get complex. To remedy that, you can now instruct an FLV to shell out to your installed Gnuplot and plot itself. The images are saved in your system's tmpdir.
 
 ## 1.0.1, 28 June 2013

data/README.md

@@ -83,3 +83,7 @@ Plots of the examples' fuzzy linguistic variables have been pre-rendered and are
 * "Fuzzy Logic: The Revolutionary Computer Technology that is Changing the World" by Daniel McNeill & Paul Freiberger [(Amazon link)](http://www.amazon.com/Fuzzy-Logic-Revolutionary-Computer-Technology/dp/0671875353/)
 * "Fuzzy Logic in Decision Making and Signal Processing" by Sujit Nath Pant & Keith E. Holbert [(Link)](http://enpub.fulton.asu.edu/powerzone/fuzzylogic/index.htm)
 * "Programming Game AI by Example" by Mat Buckland [(Amazon link)](http://www.amazon.com/Programming-Game-Example-Mat-Buckland/dp/1556220782)
+
+
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/cpowell/fuzzy-associative-memory/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+

data/bin/hvac_system_example.rb

@@ -1,4 +1,9 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env ruby --server -Xcompile.invokedynamic=true
+#
+# The shebang line, above, should reflect your Ruby.
+# - Vanilla ruby 1.9/2.0 : #!/usr/bin/env ruby
+# - Jruby: #!/usr/bin/env ruby --server
+# - Jruby 1.7 with Java 1.7: #!/usr/bin/env ruby --server -Xcompile.invokedynamic=true
 #
 # Copyright 2013, Prylis Incorporated.
 #
@@ -7,6 +12,7 @@
 # You can redistribute and/or modify this software only in accordance with
 # the terms found in the "LICENSE" file included with the library.
 #
+$:.push File.expand_path('../../lib/', __FILE__)
 require 'fuzzy_associative_memory'
 
 # Set me to true to enable some verbose output of my calculations...
@@ -24,30 +30,30 @@ $verbosity = false
 temperature_in = FuzzyAssociativeMemory::LinguisticVariable.new("room temperature") # degrees fahrenheit
 
 # Wider: less important, coarse control; narrower: more important, fine control
-cold       = FuzzyAssociativeMemory::Trapezoid.new(40, 40, 40, 50)  # 20 deg wide
-cool       = FuzzyAssociativeMemory::Triangle.new(45, 55, 65)  # 20 deg wide
-just_right = FuzzyAssociativeMemory::Triangle.new(60, 65, 70)  # 10 deg wide
-warm       = FuzzyAssociativeMemory::Triangle.new(65, 75, 85)  # 20 deg wide
-hot        = FuzzyAssociativeMemory::Trapezoid.new(80, 90, 90, 90) # 20 deg wide
+cold       = FuzzyAssociativeMemory::Trapezoid.new(40, 40, 40, 50)
+cool       = FuzzyAssociativeMemory::Triangle.new(45, 55, 65)
+just_right = FuzzyAssociativeMemory::Triangle.new(60, 65, 70)
+warm       = FuzzyAssociativeMemory::Triangle.new(65, 75, 85)
+hot        = FuzzyAssociativeMemory::Trapezoid.new(80, 90, 90, 90)
 
 temperature_in.sets = [cold, cool, just_right, warm, hot]
 # Comment out if you don't have Gnuplot installed:
-temperature_in.gnuplot({:logarithmic_x=>false})
+# temperature_in.gnuplot({:logarithmic_x=>false})
 
 # The output side -- the consequent -- expressed as a number of fuzzy sets,
 # with each set representing a natural-language description. The 'resultant
 # fan speed' variable, is the  assemblage of all our fuzzy output sets.
 fan_speed = FuzzyAssociativeMemory::LinguisticVariable.new("fan speed") # cubic feet per minute (CFM)
 
-stop   = FuzzyAssociativeMemory::Triangle.new(-30, 0, 30)   # 60 CFM wide
-slow   = FuzzyAssociativeMemory::Triangle.new(10, 30, 50)   # 40 CFM wide
-medium = FuzzyAssociativeMemory::Triangle.new(40, 50, 60)   # 20 CFM wide
-fast   = FuzzyAssociativeMemory::Triangle.new(50, 70, 90)   # 40 CFM wide
-blast  = FuzzyAssociativeMemory::Triangle.new(70, 100, 130) # 60 CFM wide
+stop   = FuzzyAssociativeMemory::Triangle.new(-30, 0, 30)
+slow   = FuzzyAssociativeMemory::Triangle.new(10, 30, 50)
+medium = FuzzyAssociativeMemory::Triangle.new(40, 50, 60)
+fast   = FuzzyAssociativeMemory::Triangle.new(50, 70, 90)
+blast  = FuzzyAssociativeMemory::Triangle.new(70, 100, 130)
 
 fan_speed.sets = [stop, slow, medium, fast, blast]
 # Comment out if you don't have Gnuplot installed:
-fan_speed.gnuplot({:logarithmic_x=>false})
+# fan_speed.gnuplot({:logarithmic_x=>false})
 
 # Natural-language marriage of the inputs to the outputs, e.g.
 # "If the temperature is cool, the fan motor speed should be slow."
@@ -65,6 +71,16 @@ system.rules = [rule_1, rule_2, rule_3, rule_4, rule_5]
 # puts "The #{system.name} determines: for #{temperature_in.name} #{n}, the #{fan_speed.name} is #{system.calculate(n)} CFM"
 
 # Check the logic for a wide range of temps and output the results
-(40..90).each do |n|
-  puts "The #{system.name} determines: for #{temperature_in.name} #{n}, the #{fan_speed.name} is #{system.calculate(n)} CFM"
-end
+#require 'jruby/profiler'
+#profile_data = JRuby::Profiler.profile do
+  50000.times do
+    (40..90).each do |n|
+      system.calculate(n)
+      #puts "The #{system.name} determines: for #{temperature_in.name} #{n}, the #{fan_speed.name} is #{system.calculate(n)} CFM"
+    end
+  end
+#end
+
+# profile_printer = JRuby::Profiler::FlatProfilePrinter.new(profile_data)
+# profile_printer.printProfile(STDOUT)
+

data/bin/weapon_choice_example.rb

@@ -7,6 +7,7 @@
 # You can redistribute and/or modify this software only in accordance with
 # the terms found in the "LICENSE" file included with the library.
 #
+$:.push File.expand_path('../../lib/', __FILE__)
 require 'fuzzy_associative_memory'
 
 # Set me to true to enable some verbose output of my calculations...

data/lib/fuzzy_associative_memory/rule.rb

@@ -49,23 +49,26 @@ class FuzzyAssociativeMemory::Rule
   #
   def fire(value_array)
     raise ArgumentError, "value array passed to Rule::fire() cannot be nil" if value_array.nil?
-    raise ArgumentError, "value array must be an collection of inputs but is a #{value_array.class}" unless value_array.is_a? Enumerable
+    raise ArgumentError, "value array must be an collection of inputs but is a #{value_array.class}" unless value_array.is_a? Array
     raise ArgumentError, "value array passed to Rule::fire() cannot be empty" if value_array.empty?
 
-    mus = Array.new
-    # puts value_array.join(", ")
-    @antecedents.each_with_index do |antecedent, index|
-      mus[index] = antecedent.mu(value_array[index])
+    ant_len = @antecedents.length
+    raise ArgumentError, "value array size must equal antecedent array size" if value_array.length != ant_len
+
+    for i in 0..ant_len-1
+      v = @antecedents[i].mu(value_array[i])
+      @max = v if @max.nil? || v > @max
+      @min = v if @min.nil? || v < @min
     end
 
     if @boolean==:and
-      mu = mus.min # AND / Intersection == minimum
+      return @min # AND / Intersection == minimum
     else
-      mu = mus.max # OR / Union == maximum
+      return @max # OR / Union == maximum
     end
 
-    puts "Fired rule '#{@natural_language}': µ choices are [#{mus.join(',')}], final µ is #{mu}" if $verbosity
-    [@consequent, mu]
+    # puts "Fired rule '#{@natural_language}': µ choices are [#{@mus.join(',')}], final µ is #{mu}" if $verbosity
+    # [@consequent, mu]
   end
 
 end

data/lib/fuzzy_associative_memory/ruleset.rb

@@ -17,6 +17,7 @@ class FuzzyAssociativeMemory::Ruleset
     @name  = name
     @rules = []
     @implication = implication_mechanism
+    @consequent_mus   = {}
   end
 
   def add_rule(rule)
@@ -24,64 +25,54 @@ class FuzzyAssociativeMemory::Ruleset
   end
 
   def calculate(*input_values)
-    @consequent_mus   = {}
-    @consequents      = []
-
-    puts ">>> Firing all rules..." if $verbosity
-    @rules.each_with_index do |rule, rule_num|
+    # puts ">>> Firing all rules..." if $verbosity
+    for rule in @rules
       # Fire each rule to determine the µ value (degree of fit).
       # Gather the µ vals by consequent, since each consequent may in fact
       # have been fired more than once and we'll need that knowledge in a
       # moment...
-      cons, mu = rule.fire(input_values)
+      mu = rule.fire(input_values)
+      cons = rule.consequent
 
       # Since any given consequent may have been activated more than once, we
       # need to get just a single µ value out -- we only care about the 'best'
       # µ. A popular way of doing so is to OR the values together, i.e. keep the
       # maximum µ value and discard the others.
-      if @consequent_mus.has_key?(cons)
-        if mu > @consequent_mus[cons]
-          @consequent_mus[cons] = mu
-        end
-      else
-        @consequent_mus[cons] = mu
-      end
+      curr_best = @consequent_mus[cons]
+      @consequent_mus[cons] = mu if curr_best.nil? || mu > curr_best
     end
 
     # Using each µ value, alter the consequent fuzzy set's polgyon. This is
     # called implication, and 'weights' the consequents properly. There are
     # several common ways of doing it, such as Larsen (scaling) and Mamdani
     # (clipping).
+    numerator=0
+    denominator=0
+
     @consequent_mus.each do |cons, mu|
       case @implication
       when :mamdani
-        @consequents << cons.mamdani(mu)
+        tmp = cons.mamdani(mu)
       when :larsen
-        @consequents << cons.larsen(mu)
+        tmp = cons.larsen(mu)
       else
         raise RuntimeError, "I must have been passed an unknown implication mechanism: #{@implication}"
       end
-    end
-
-    # Defuzzify into a discrete & usable value by adding up the weighted
-    # consequents' contributions to the output. Again there are several ways
-    # of doing it, such as computing the centroid of the combined 'mass', or
-    # the 'mean of maximum' of the tallest set(s). Here we use the "Average
-    # of Maxima" summation mechanism. MaxAv is defined as:
-    # (∑ representative value * height) / (∑ height) for all output sets
-    # where 'representative value' is shape-dependent.
-    numerator=0
-    denominator=0
 
-    @consequents.each do |cons|
-      numerator += cons.centroid_x * cons.height
-      denominator += cons.height
+      # Defuzzify into a discrete & usable value by adding up the weighted
+      # consequents' contributions to the output. Again there are several ways
+      # of doing it, such as computing the centroid of the combined 'mass', or
+      # the 'mean of maximum' of the tallest set(s). Here we use the "Average
+      # of Maxima" summation mechanism. MaxAv is defined as:
+      # (∑ representative value * height) / (∑ height) for all output sets
+      # where 'representative value' is shape-dependent.
+      numerator += tmp.centroid_x * tmp.height
+      denominator += tmp.height
     end
 
-    return numerator/denominator
+    @consequent_mus.clear
 
-    # numerator_terms   = @consequents.map { |set| set.centroid_x * set.height }
-    # denominator_terms = @consequents.map { |set| set.height }
-    # numerator_terms.inject{|sum,x| sum + x } / denominator_terms.inject{|sum,x| sum + x }
+    return numerator/denominator
   end
+
 end

data/lib/fuzzy_associative_memory/triangle.rb

@@ -30,9 +30,7 @@ class FuzzyAssociativeMemory::Triangle < FuzzyAssociativeMemory::FuzzySet
   end
 
   def centroid_x
-    cx = (@left + @right + @center) / 3.0
-    # cy = @height / 3.0
-    # [cx, cy]
+    (@left + @right + @center) / 3.0
   end
 
   def height=(new_height)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fuzzy_associative_memory
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
   prerelease:
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-08-23 00:00:00.000000000 Z
+date: 2013-09-02 00:00:00.000000000 Z
 dependencies: []
 description: |2
       A Fuzzy Associative Memory (FAM for short) is a Fuzzy Logic tool for decision making. Fuzzy logic FAMs have a wide range of practical applications: Control systems, such as governing a fan to keep a room at the "just right" temperature; Game AI, such as imbuing bots with human-like decision-making behavior; Prediction systems, linking causes with effects. A FAM uses Fuzzy Sets to establish a set of rules that are linguistic in nature. The linguistic rules, and the fuzzy sets they contain, are defined by a human "expert" (presumably, you). The rules therefore codify intelligence and map this knowledge from the human domain to the digital.