fuzzyrb 1.1.0 → 1.2.0

data/History.txt

@@ -1,9 +1,17 @@
+== 1.2.0 / 2007-11-16
+
+* Some bugfixes
+* Changed how evaluate method is invoked. Now it takes hash of params.
+* Closed code in a module.
+* Added some docs.
+
 == 1.1.0 / 2007-11-15
+
 * Added Takegi-Sugeno rules
 * Added first minimum defuziffication method
-
 * Changed inference to implementation
 * Changed weightCenter to centerOfGravity
+
 == 1.0.0 / 2007-11-09
 
 * 1 major enhancement

data/Manifest.txt

@@ -2,6 +2,7 @@ History.txt
 Manifest.txt
 README.txt
 Rakefile
+examples/compare_models.rb
 index.html
 lib/fuzzy.rb
 lib/fuzzy_implication.rb
@@ -13,3 +14,4 @@ test/test_fuzzy.rb
 test/test_fuzzy_implication.rb
 test/test_fuzzy_rule.rb
 test/test_fuzzy_set.rb
+test/test_point.rb

data/README.txt

@@ -8,15 +8,17 @@ Implements Fuzzy Sets in Ruby. I am very beginner at this topic, so it is very b
 
 == FEATURES/PROBLEMS:
   
-* Fuzzy Sets defined as line segments
+* Fuzzy Sets defined as sequence of line segments.
 * Fuzzy Rules. Only conjunction of arguments is possible.
 * No error handling.
-* Deffuzification as center of gravity.
-* Reasoning - apply matching rule and combine the results.
+* Defuzzification as center of gravity and first maximum
+* Minimum and Multiplication T-Norms.
+* Mamdami and Larsen aggregation methods.
+* Reasoning - apply matching rule and combine the results. Mamdami or Takagi-Sugeno system.
 
 == SYNOPSIS:
 
-  Cannot be used from console. See test/ for sample usage.
+Cannot be used from console. See test/ and example/ for sample usage.
 
 == REQUIREMENTS:
 
@@ -46,5 +48,6 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 == Author
+
 Roman 'MrStone' Kamyk (mailto:roman.kamyk@gmail.com), 
 Student of Poznan University Of Technology, Computing Science Institute, Inteligent Decision Support Systems

data/Rakefile

@@ -10,15 +10,16 @@ namespace :hoe do
     p.author         = 'Roman Kamyk'
     p.email          = 'roman.kamyk@gmail.com'
     p.summary        = 'Fuzzy Sets for Ruby'
-    p.description    = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+    p.description    = p.paragraphs_of('README.txt', 1..2).join("\n\n")
     p.url            = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
-    p.changes        = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+    @changes = p.changes        = p.paragraphs_of('History.txt', 0..1).join("\n\n")
   end
 end
 
-task :publish => ['hoe:release', 'hoe:post_news', 'hoe:publish_docs'] do
+task :commit_changes do
   sh "svn ci -m '#{@changes}'"
   sh "hg ci -m '#{@changes}'"
 end
 
+task :publish => ['hoe:release', 'hoe:post_news', 'hoe:publish_docs', 'commit_changes']
 # vim: syntax=Ruby

data/examples/compare_models.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/ruby
+# (c) Copyright 2007 Roman Kamyk.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+##############################################################################
+# In this example we try to model the function f(x, y) = x + y using different
+# parameters. As a result we get couple graphs of difference between the model
+# and the function and sum of errors (differences)
+
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+require 'fuzzy'
+@smallInput = FuzzySet.trapezoid([0, 0, 0, 10])
+@largeInput = FuzzySet.trapezoid([0, 10, 10, 10])
+@smallOutput = FuzzySet.trapezoid([0, 0, 0, 10])
+@mediumOutput = FuzzySet.trapezoid([0, 10, 10, 20])
+@largeOutput = FuzzySet.trapezoid([10, 20, 20, 20])
+@rule1 = FuzzyRule.new([@smallInput, @smallInput], @smallOutput)
+@rule2 = FuzzyRule.new([@smallInput, @largeInput], @mediumOutput)
+@rule3 = FuzzyRule.new([@largeInput, @smallInput], @mediumOutput)
+@rule4 = FuzzyRule.new([@largeInput, @largeInput], @largeOutput)
+@ms = MamdamiImplication.new([@rule1, @rule2, @rule3, @rule4])
+
+@rulets1 = FuzzyRule.new([@smallInput, @smallInput], Proc.new { |a, b| 0})
+@rulets2 = FuzzyRule.new([@smallInput, @largeInput], Proc.new { |a, b| 10})
+@rulets3 = FuzzyRule.new([@largeInput, @smallInput], Proc.new { |a, b| 10})
+@rulets4 = FuzzyRule.new([@largeInput, @largeInput], Proc.new { |a, b| 20})
+@tss = TakagiSugenoImplication.new([@rulets1, @rulets2, @rulets3, @rulets4])
+
+require 'rubygems'
+require 'gnuplot'
+@sum_of_diffs = {}
+def count_error(implication, params)
+  Gnuplot.open do |gp|
+    Gnuplot::SPlot.new( gp ) do |plot|
+      plot.title  "#{params.inspect}"
+      plot.xlabel "a"
+      plot.ylabel "b"
+      plot.set("ticslevel", "0.8")
+      plot.set("isosample", "40,40")
+
+      range = 0..10
+      x = range.collect {|v| v.to_f}
+      y = x
+      z = []
+      pp params
+      for i in range do
+        z << []
+        for j in range do
+          # print " T_Norm: #{t_norm}, implication: #{imp_type}, deffuzification: #{def_type}, difference: "
+          res = implication.evaluate([i, j],params)
+          diff = (res - (i+j)).abs
+          @sum_of_diffs[params] ||= 0
+          @sum_of_diffs[params] += diff
+          puts "[#{i}, #{j}] #{res} - #{i+j} = #{res - (i+j)}"
+          z[i] << diff
+        end
+      end
+      plot.data << Gnuplot::DataSet.new( [x, y, z] ) do |ds|
+        ds.with = "lines"       
+      end
+    end
+  end
+end
+
+[:min, :mult].each do |t_norm|
+  count_error(@tss, :t_norm => t_norm, :implication => :takegiSugeno)
+  [:mamdani, :larsen].each do |imp_type|
+    [:CoG, :firstMaximum].each do |def_type|
+      count_error(@ms, :t_norm => t_norm, :implication => imp_type, :defuzzification => def_type)
+    end
+  end
+  # print "[#{i}, #{j}] T_norm: #{t_norm}, implication: Takagi Sugeno, difference: "
+  # res = @tss.evaluate([i, j], t_norm)
+  # sum_of_diffs[[t_norm, :ts]] ||= 0
+  # sum_of_diffs[[t_norm, :ts]] += (res - (i+j)).abs
+  # puts "#{res} - #{i+j} = #{res - (i+j)}"
+end
+pp @sum_of_diffs

data/lib/fuzzy.rb

@@ -2,22 +2,51 @@
 #  Created by Roman Kamyk <roman.kamyk@gmail.com on 2007-11-09.
 #  Copyright (C) 2007 Roman Kamyk
 #  
-#  This program is free software: you can redistribute it and/or modify
-#  it under the terms of the GNU General Public License as published by
-#  the Free Software Foundation, either version 3 of the License, or
-#  (at your option) any later version.
-#  
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#  
-#  You should have received a copy of the GNU General Public License
-#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 require 'pp'
-
 $:.unshift(File.dirname(__FILE__) + "/../lib/")
+
+EPSILON = 0.0001
+SCALE = 1
+
+class Array
+  def uniq_values
+    uniqArray = []
+    self.each { |e1|
+      uniqArray << e1 unless uniqArray.find{ |o| o.eql?(e1) }
+    }
+    uniqArray
+  end
+  
+  def uniq_values!()
+    test = self.dup
+    self.clear
+    test.each { |e1|
+      self << e1 unless self.find{ |o| o.eql?(e1) }
+    }
+    self
+  end
+  
+  def non_decreasing
+    for i in 1..self.length-1
+        return false if self[i-1] > self[i]
+    end
+    return true
+  end
+end
+
 require 'point'
 require 'line'
 require 'fuzzy_set'
@@ -25,5 +54,5 @@ require 'fuzzy_rule'
 require 'fuzzy_implication'
 
 module Fuzzyrb
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/fuzzy_implication.rb

@@ -1,31 +1,45 @@
-class FuzzyImplication
-  def initialize(rules)
-    @rules = rules
-  end
-end
-
-class TakagiSugenoImplication < FuzzyImplication
-  def evaluate(t_norm, values)
-    sum = 0
-    result = @rules.map { |rule|
-      rule.evaluate(t_norm, :takagiSugeno, values)
-    }.inject(0) { |s, rv| sum += rv[1]; s + rv[0] }
-    return 0 if sum == 0
-    result/sum
+module Fuzzyrb
+  # Should not be used directly. Use <tt>TakagiSugenoImplication</tt> or
+  # <tt>MamdamiImplication</tt>
+  class FuzzyImplication
+    def initialize(rules)
+      @rules = rules
+    end
   end
-end
 
-class MamdamiImplication < FuzzyImplication
-  def evaluate(t_norm, implication, defuzzification, values)
-    result = @rules.map { |rule|
-      rule.evaluate(t_norm, implication, values)
-    }.inject { |s, r| s + r }
-    if defuzzification == :CoG
-      return result.centerOfGravity
-    elsif defuzzification == :firstMin
-      return result.firstMinimum
-    else
-      raise Exception.new("Invalid deffuzification method")
+  # Uses Takegi-Sugeno system to compute implication. Each rule as its
+  # conclusion has function of it's arguments.
+  class TakagiSugenoImplication < FuzzyImplication
+    # Evaluates the rule. Params are the same as for
+    # <tt>FuzzyRule</tt>
+    def evaluate(values, params)
+      # puts "\nEvaluating ts implication"
+      total_membership = 0
+      params[:implication] = :takagiSugeno
+      total_value = @rules.map { |rule|
+        rule.evaluate(values, params)
+        }.inject(0) { |s, rv| total_membership += rv[1]; s + rv[0]*rv[1]}
+        # puts "TM: #{total_membership}, TV: #{total_value}"
+        return 0 if total_membership == 0
+        total_value/total_membership
+      end
     end
-  end
-end
+
+    class MamdamiImplication < FuzzyImplication
+      # Evaluates the rule. Params includes <tt>FuzzyRule</tt> params and:
+      # * <tt>:defuzzification</tt> which can be <tt>:CoG</tt> for center of gravity of
+      #   <tt>:firstMaximum</tt> for first maximum.
+      def evaluate(values, params)
+        result = @rules.map { |rule|
+          rule.evaluate(values, params)
+          }.inject { |s, r| s + r }
+          if params[:defuzzification] == :CoG
+            return result.centerOfGravity
+          elsif params[:defuzzification] == :firstMaximum
+            return result.firstMaximum
+          else
+            raise Exception.new("Invalid defuzzification method")
+          end
+        end
+      end
+    end

data/lib/fuzzy_rule.rb

@@ -1,35 +1,46 @@
-class FuzzyRule
-  def initialize(arguments, result)
-    @arguments = arguments
-    @result = result
-  end  
- 
-  def evaluate(t_norm, implication, values)
-    if t_norm == :min
-      val = argumentsValues(values).min
-    elsif t_norm == :mult
-      val = argumentsValues(values).inject(1) { |mult, v| mult*v}
-    elsif
-      raise Exception.new("Invalid t_norm")
+module Fuzzyrb
+  class FuzzyRule
+    # Creates rule.
+    # First argument is an Array of premises (<tt>FuzzySet</tt>). Second is result. It is either <tt>FuzzySet</tt> or <tt>Proc</tt>.
+    def initialize(arguments, result)
+      @arguments = arguments
+      @result = result
+    end  
+
+    # Evaluates rule.
+    # Required parameters:
+    # * <tt>:t_norm</tt> - t_norm to use. <tt>:min</tt> for minimum or
+    #   <tt>:mult</tt> for multiplication
+    # * <tt>:implication</tt> - implication to use. Either <tt>:mamdani</tt>,
+    #   <tt>:larsen</tt>, or <tt>:takegiSugeno</tt>. If you use
+    #   <tt>:takegiSugeno</tt> make sure that rule result is a Proc. 
+    def evaluate(values, params)
+      if params[:t_norm] == :min
+        val = argumentsValues(values).min
+      elsif params[:t_norm] == :mult
+        val = argumentsValues(values).inject(1) { |mult, v| mult*v}
+      elsif
+        raise Exception.new("Invalid t_norm")
+      end
+      if params[:implication] == :mamdani
+        return @result.min(val)
+      elsif params[:implication] == :larsen
+        return @result.scale(val)
+      elsif params[:implication] == :takagiSugeno
+        #rule value and certainity
+        return [@result.call(values), val]
+      else
+        raise Exception.new("Invalid type")
+      end
     end
-    if implication == :mamdani
-      return @result.min(val)
-    elsif implication == :larsen
-      return @result.scale(val)
-    elsif implication == :takagiSugeno
-      #rule value and certainity
-      return [@result.call(values), val]
-    else
-      raise Exception.new("Invalid type")
+
+    private
+    def argumentsValues(values)
+      tmp = []
+      for i in 0..(values.length-1)
+        tmp << @arguments[i][values[i]]
+      end
+      tmp
     end
   end
-  
-  private
-  def argumentsValues(values)
-    tmp = []
-    for i in 0..(values.length-1)
-      tmp << @arguments[i][values[i]]
-    end
-    tmp
-  end
 end

data/lib/fuzzy_set.rb

@@ -1,126 +1,134 @@
-EPSILON = 0.0001
-SCALE = 1
-class FuzzySet      
-  def self.trapezoid(array)
-    raise Exception.new("Trapezoid must have array length 4") if array.length != 4
-    points = []
-    points << Point.new(array[0], 0)
-    points << Point.new(array[1], SCALE)
-    points << Point.new(array[2], SCALE) unless array[2] == array[1]
-    points << Point.new(array[3], 0)
-    FuzzySet.new(points)
-  end
+module Fuzzyrb
+  class FuzzySet      
+    def self.trapezoid(array)
+      raise Exception.new("Trapezoid must have array length 4") if array.length != 4
+      raise Exception.new("Trapezoid arguments must be nondecreasing") unless array.non_decreasing
+      points = []
+      points << Point.new(array[0], 0) unless array[1] == array[0]
+      points << Point.new(array[1], SCALE) 
+      points << Point.new(array[2], SCALE) unless array[2] == array[1]
+      points << Point.new(array[3], 0) unless array[3] == array[2]
+      FuzzySet.new(points)
+    end
 
-  def initialize(points)
-    @points = points.sort
-  end
-  
-  def +(other)
-    points = [@points, other.points, intersections(other)].flatten.uniq.sort
-    res = points.reject { |point|
-       self[point.x]-EPSILON > point.y or other[point.x]-EPSILON > point.y
-    }
-    FuzzySet.new(res)
-  end
-  
-  def min(value)
-    line = Line.new(Point.new(0, value), Point.new(1, value))
-    points = [@points, intersections(line)].flatten.uniq.sort
-    res = points.reject { |p| self[p.x] - EPSILON > value }
-    FuzzySet.new(res)
-  end
-  
-  # Choose min of current and _other_ set
-  def &(other)
-    points = [@points, crosspoints(other)].flatten.uniq.sort
-    res = []
-    points.each { |point|
-      res << point if self[point.x]-EPSILON < point.y and self[point.x]+EPSILON > point.y and other[point.x]+EPSILON >= self[point.x]
-    }
-    FuzzySet.new(res)
-  end
-  attr_reader :points
-  
-  def centerOfGravity()
-    nominator = 0.0
-    denominator = 0.0
-    for i in 1..@points.length-1
-      line = Line.new(@points[i], @points[i-1])
-      x2 = points[i].x
-      x1 = points[i-1].x
-      nominator += line.a * x2**3/3 + line.b * x2**2/2 - line.a * x1**3/3 - line.b * x1**2/2
-      denominator += line.a * x2**2/2 + line.b * x2 - line.a * x1**2/2 - line.b * x1
+    def initialize(points)
+      @points = points.sort.uniq_values
     end
-    nominator/denominator
-  end
-  
-  def firstMinimum()
-    maxIdx = 0
-    for i in 0..@points.length-1
-      if @points[i].y > @points[maxIdx].y
-        maxIdx = i
+
+    def +(other)
+      points = [@points, other.points, intersections(other)].flatten.uniq_values.sort
+      res = points.reject { |point|
+        self[point.x]-EPSILON > point.y or other[point.x]-EPSILON > point.y
+      }
+      FuzzySet.new(res)
+    end
+
+    def min(value)
+      line = Line.new(Point.new(0, value), Point.new(1, value))
+      points = [@points, intersections(line)].flatten.uniq_values.sort
+      # reject all points that has higher membership than this fuzzy set
+      res = points.reject { |p| self[p.x] - EPSILON > value }
+      FuzzySet.new(res)
+    end
+
+    # Choose min of current and _other_ set
+    def &(other)
+      points = [@points, crosspoints(other)].flatten.uniq_values.sort
+      res = []
+      points.each { |point|
+        res << point if self[point.x]-EPSILON < point.y and self[point.x]+EPSILON > point.y and other[point.x]+EPSILON >= self[point.x]
+      }
+      FuzzySet.new(res)
+    end
+    attr_reader :points
+
+    def centerOfGravity()
+      nominator = 0.0
+      denominator = 0.0
+      # puts "Length: #{@points.length}"
+      for i in 1..@points.length-1
+        line = Line.new(@points[i], @points[i-1])
+        # puts "#{nominator}, #{denominator}, #{line.a}, #{line.b}"
+        # pp @points[i], @points[i-1]
+        x2 = points[i].x
+        x1 = points[i-1].x
+        nominator += line.a * x2**3/3 + line.b * x2**2/2 - line.a * x1**3/3 - line.b * x1**2/2
+        denominator += line.a * x2**2/2 + line.b * x2 - line.a * x1**2/2 - line.b * x1
       end
+
+      return 0 if nominator.abs <= EPSILON
+      raise Exception.new("Runtime exception: denominator cannot be null") if denominator == 0
+      nominator/denominator
     end
-    @points[maxIdx].x
-  end
-  
-  def scale(factor)
-    fs = FuzzySet.new(@points.map { |p| p.clone() })
-    fs.scale!(factor)
-  end
-  
-  def scale!(factor)
-    @points.each { |point| point.y *= factor / SCALE }
-    self
-  end
-  
-  def [](value)
-    if value<@points[0].x
-      return 0
-    elsif value > @points.last.x
-      return 0
+
+    def firstMaximum()
+      maxIdx = 0
+      for i in 0..@points.length-1
+        if @points[i].y > @points[maxIdx].y
+          maxIdx = i
+        end
+      end
+      @points[maxIdx].x
     end
-    idx = 0
-    while (@points[idx].x < value)
-      idx += 1
+
+    def scale(factor)
+      fs = FuzzySet.new(@points.map { |p| p.clone() })
+      fs.scale!(factor)
     end
-    return @points[idx].y if @points[idx].x == value
-    x1 = @points[idx-1].x
-    x2 = @points[idx].x
-    y1 = @points[idx-1].y
-    y2 = @points[idx].y
-    return 1.0*(y2 - y1)/(x2-x1) * (value - x1) + y1
-  end
-  
-  def toLines
-    lines = []
-    for i in 1..@points.length-1
-      lines << Line.new(@points[i], @points[i-1])
+
+    def scale!(factor)
+      @points.each { |point| point.y *= factor / SCALE }
+      self
     end
-    lines
-  end
-  
-  private
-  def intersections(other)
-    if other.is_a?(Line)
-      points = []
-      toLines.each { |mline| 
-        points << mline.intersect(other)
-      }
-      points.select { |point| (self[point.x]-point.y).abs <= EPSILON }
-    elsif other.is_a?(FuzzySet)
-      myLines = toLines
-      points = []
-      other.toLines.each { |line| 
-        myLines.each { |mline|
-          points << mline.intersect(line)
+
+    def [](value)
+      if value<@points[0].x
+        return @points[0].y
+      elsif value > @points.last.x
+        return @points.last.y
+      end
+      idx = 0
+      while (@points[idx].x < value)
+        idx += 1
+      end
+      return @points[idx].y if @points[idx].x == value
+      x1 = @points[idx-1].x
+      x2 = @points[idx].x
+      y1 = @points[idx-1].y
+      y2 = @points[idx].y
+      return 1.0*(y2 - y1)/(x2-x1) * (value - x1) + y1
+    end
+
+    def toLines
+      lines = []
+      for i in 1..@points.length-1
+        lines << Line.new(@points[i], @points[i-1])
+      end
+      lines
+    end
+
+    private
+    def intersections(other)
+      if other.is_a?(Line)
+        points = []
+        toLines.each { |mline| 
+          points << mline.intersect(other)
         }
-      }
-      points.select { |point|
-        (self[point.x]-point.y).abs + (other[point.x]-point.y).abs <= EPSILON
-      }
-    else
-      raise Exception.new("Unable to count intersection")
+        points.select { |point| (self[point.x]-point.y).abs <= EPSILON }
+      elsif other.is_a?(FuzzySet)
+        myLines = toLines
+        points = []
+        other.toLines.each { |line| 
+          myLines.each { |mline|
+            points << mline.intersect(line)
+          }
+        }
+        points.select { |point|
+          (self[point.x]-point.y).abs + (other[point.x]-point.y).abs <= EPSILON
+        }
+      else
+        raise Exception.new("Unable to count intersection")
+      end
     end
   end
-end
+end

data/lib/line.rb

@@ -1,16 +1,18 @@
-class Line
-  def initialize(p1, p2)
-    @a = 1.0*(p2.y-p1.y)/(p2.x-p1.x)
-    @b = 1.0*p1.y - @a*p1.x
-    # pp [p1, p2, @a, @b]
+module Fuzzyrb
+  class Line
+    def initialize(p1, p2)
+      @a = 1.0*(p2.y-p1.y)/(p2.x-p1.x)
+      @b = 1.0*p1.y - @a*p1.x
+      # pp [p1, p2, @a, @b]
+    end
+
+    def intersect(other)
+      x = 1.0*(b-other.b)/(other.a-a)
+      y = 1.0*a*x+b
+      # pp [self, other, x, y]
+      Point.new(x, y)
+    end
+
+    attr_accessor :a, :b
   end
-  
-  def intersect(other)
-    x = 1.0*(b-other.b)/(other.a-a)
-    y = 1.0*a*x+b
-    # pp [self, other, x, y]
-    Point.new(x, y)
-  end
-  
-  attr_accessor :a, :b
 end

data/lib/point.rb

@@ -1,14 +1,25 @@
-class Point
-  def initialize(x, y)
-    @x = x
-    @y = y
-  end  
-  def <=>(other)
-    self.x <=> other.x
+module Fuzzyrb
+  class Point
+    def initialize(x, y)
+      @x = x
+      @y = y
+    end  
+
+    def <=>(other)
+      self.x <=> other.x
+    end
+
+    def eql?(other)
+      if (self.x-other.x).abs <= EPSILON and (self.y - other.y).abs <= EPSILON
+        return true
+      end
+      return false
+    end
+
+    def initialize_copy(orig)
+      @x = orig.x
+      @y = orig.y
+    end
+    attr_accessor :x, :y
   end
-  def initialize_copy(orig)
-    @x = orig.x
-    @y = orig.y
-  end
-  attr_accessor :x, :y
-end
+end

data/test/test_fuzzy.rb

@@ -3,6 +3,10 @@ $:.unshift(File.dirname(__FILE__) + "/../test/")
 require 'test/unit'
 require 'test/unit/ui/console/testrunner'
 
+require 'fuzzy'
+include Fuzzyrb
+
 require 'test_fuzzy_set'
 require 'test_fuzzy_rule'
-require 'test_fuzzy_implication'
+require 'test_fuzzy_implication'
+require 'test_point'

data/test/test_fuzzy_implication.rb

@@ -1,7 +1,6 @@
 #!/usr/bin/ruby
-$:.unshift(File.dirname(__FILE__) + "/../lib/")
+$:.unshift(File.dirname(__FILE__) + "../lib/")
 require 'test/unit'
-require 'fuzzy'
 
 class TestFuzzyImplication < Test::Unit::TestCase
   def setup
@@ -21,15 +20,15 @@ class TestFuzzyImplication < Test::Unit::TestCase
   end
   
   def test_mamdani
-    assert_in_delta 33.71, @fi.evaluate(:min, :mamdani, :CoG, [7, 18]), 0.005
+    assert_in_delta 33.71, @fi.evaluate([7, 18], {:t_norm => :min, :implication => :mamdani, :defuzzification => :CoG}), 0.005
   end
   
   def test_larsen
-    assert_in_delta 33.58, @fi.evaluate(:min, :larsen, :CoG, [7, 18]), 0.005
+    assert_in_delta 33.58, @fi.evaluate([7, 18], {:t_norm => :min, :implication => :larsen, :defuzzification => :CoG}), 0.005
   end
   
   def test_takagi_sugeno
-    assert_equal 0, @tsi.evaluate(:min, [10, 20])
-    assert_equal 8.75, @tsi.evaluate(:min, [5, 19])    
+    assert_equal 0, @tsi.evaluate([10, 20], :t_norm => :min)
+    assert_equal 19.25, @tsi.evaluate([5, 19], :t_norm => :min)    
   end
 end

data/test/test_fuzzy_rule.rb

@@ -11,8 +11,8 @@ class TestFuzzyRule < Test::Unit::TestCase
   end
   
   def test_larsen
-    assert_equal [25, 0.25], @rule.evaluate(:min, :takagiSugeno, [7, 18])
-    assert_equal [16, 1], @rule.evaluate(:min, :takagiSugeno, [5, 11])
+    assert_equal [25, 0.25], @rule.evaluate([7, 18], {:t_norm => :min, :implication => :takagiSugeno} )
+    assert_equal [16, 1], @rule.evaluate([5, 11], {:t_norm => :min, :implication => :takagiSugeno})
   end
 end
 

data/test/test_fuzzy_set.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
 require 'test/unit'
 require 'fuzzy'
 
@@ -25,6 +26,65 @@ class TestFuzzySet < Test::Unit::TestCase
     assert_equal(0, t[20])
     assert_equal(0, t[1000])
   end
-end
 
+  def test_trapezoid3
+    t = FuzzySet.trapezoid([0, 10, 10, 10])
+    assert_equal 0, t[0]
+    assert_equal(1, t[10])
+    assert_equal(1, t[20])
+    assert_equal(1, t[100])
+    assert_equal(0.5, t[5])
+    assert_equal(0, t[-100])
+  end
+  
+  def test_trapezoid4
+    t = FuzzySet.trapezoid([0, 0, 0, 10])
+    assert_equal(1, t[0])
+    assert_equal(0.5, t[5])
+    assert_equal(0, t[10])
+    assert_equal(1, t[-100])
+    assert_equal(0, t[100])
+  end
 
+  def test_trapezoid5
+    t = FuzzySet.trapezoid([0, 0, 10, 20])
+    assert_equal(1, t[-100])
+    assert_equal(1, t[0])
+    assert_equal(1, t[10])
+    assert_equal(0.5, t[15])
+    assert_equal(0, t[20])
+    assert_equal(0, t[25])
+  end
+  
+  def test_trapezoid6
+    t = FuzzySet.trapezoid([0, 1, 9, 10])
+    assert_in_delta(5, t.centerOfGravity, 0.01)
+  end
+  
+  def test_nondecreasing
+    assert_raise Exception do
+      FuzzySet.trapezoid([10, 9, 8, 7])
+    end
+    assert_raise Exception do
+      FuzzySet.trapezoid([1, 0, 2, 3])
+    end
+    assert_raise Exception do
+      FuzzySet.trapezoid([1, 2, 3, 2])
+    end
+  end
+  
+  def test_points1
+    t = FuzzySet.new([Point.new(0, 0), Point.new(5, 1), Point.new(10, 0), Point.new(15, 1), Point.new(20, 0)])
+    assert_equal(0, t[0])
+    assert_equal(1, t[5])
+    assert_equal(0.5, t[2.5])
+    assert_equal(0, t[10])
+    assert_equal(0, t[-10])
+    assert_equal(1, t[15])
+    assert_equal(0.5, t[17.5])
+    assert_equal(0, t[20])
+    assert_equal(0, t[50])
+    assert_in_delta(10, t.centerOfGravity, 0.0001)
+    assert_equal(5, t.firstMaximum)
+  end
+end

data/test/test_point.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+require 'test/unit'
+require 'fuzzy'
+
+class TestPoint < Test::Unit::TestCase
+  def setup
+  end
+  
+  def test_point1
+    p1 = Point.new(0, 0)
+    p2 = Point.new(0.0, 0.0)
+    assert_equal(1, [p1, p2].uniq_values.length)
+  end
+end

metadata

@@ -3,15 +3,15 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: fuzzyrb
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
-date: 2007-11-15 00:00:00 +01:00
+  version: 1.2.0
+date: 2007-11-18 00:00:00 +01:00
 summary: Fuzzy Sets for Ruby
 require_paths: 
 - lib
 email: roman.kamyk@gmail.com
 homepage: "    by Roman Kamyk"
 rubyforge_project: fuzzyrb
-description: "== FEATURES/PROBLEMS:  * Fuzzy Sets defined as line segments * Fuzzy Rules. Only conjunction of arguments is possible. * No error handling. * Deffuzification as center of gravity. * Reasoning - apply matching rule and combine the results.  == SYNOPSIS:  Cannot be used from console. See test/ for sample usage.  == REQUIREMENTS:"
+description: "== DESCRIPTION:  Implements Fuzzy Sets in Ruby. I am very beginner at this topic, so it is very basic now. Any help will be appreciated.  == FEATURES/PROBLEMS:  * Fuzzy Sets defined as sequence of line segments. * Fuzzy Rules. Only conjunction of arguments is possible. * No error handling. * Defuzzification as center of gravity and first maximum * Minimum and Multiplication T-Norms. * Mamdami and Larsen aggregation methods. * Reasoning - apply matching rule and combine the results. Mamdami or Takagi-Sugeno system."
 autorequire: 
 default_executable: 
 bindir: bin
@@ -55,6 +55,7 @@ files:
 - Manifest.txt
 - README.txt
 - Rakefile
+- examples/compare_models.rb
 - index.html
 - lib/fuzzy.rb
 - lib/fuzzy_implication.rb
@@ -66,11 +67,13 @@ files:
 - test/test_fuzzy_implication.rb
 - test/test_fuzzy_rule.rb
 - test/test_fuzzy_set.rb
+- test/test_point.rb
 test_files: 
 - test/test_fuzzy.rb
 - test/test_fuzzy_implication.rb
 - test/test_fuzzy_rule.rb
 - test/test_fuzzy_set.rb
+- test/test_point.rb
 rdoc_options: 
 - --main
 - README.txt