ruleby 0.9.b4 → 0.9.b7

data/benchmarks/joined_rules.rb

@@ -0,0 +1,66 @@
+# This file is part of the Ruleby project (http://ruleby.org)
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# LICENSE.txt file.
+# 
+# Copyright (c) 2007 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner, Matt Smith
+#
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib/')
+require 'ruleby'
+require 'model'
+
+include Ruleby
+
+class TestRulebook < Rulebook
+  def rules(n)
+    (1..n).each do |index|
+      rule "Rule-#{index}".to_sym, 
+        [Account, :acc,
+          method.status == 'standard',
+         {method.account_id => :id}
+          ],          
+        [Address, :addr,
+          method.addr_id == b(:id),
+          method.city == 'Foobar',
+          method.state == 'FB',
+          method.zip == '12345'],
+       &lambda {|vars| }
+    end
+  end
+end
+
+def run_benchmark(rules,facts)
+  puts "running benchmark for: #{rules} rules and #{facts} facts"
+
+  t1 = Time.new
+  engine :engine do |e|   
+    TestRulebook.new(e).rules(rules)
+    
+    t2 = Time.new
+    diff = t2.to_f - t1.to_f
+    puts 'time to create rule set: ' + diff.to_s
+#e.print
+    for k in (1..facts)
+      e.assert Account.new('standard', nil, "acc#{k}")
+      e.assert Address.new("acc#{k}",'Foobar', 'FB', '12345')
+    end
+#exit(0)
+    t3 = Time.new
+    diff = t3.to_f - t2.to_f
+    puts 'time to assert facts: ' + diff.to_s
+  
+    e.match
+  
+    t4 = Time.new
+    diff = t4.to_f - t3.to_f
+    puts 'time to run agenda: ' + diff.to_s
+  end
+end
+
+run_benchmark(5, 50)
+puts '-------'
+run_benchmark(50, 50)

data/benchmarks/miss_manners/data.rb

@@ -0,0 +1,146 @@
+# This file is part of the Ruleby project (http://ruleby.org)
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# LICENSE.txt file.
+# 
+# Copyright (c) 2007 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner, Matt Smith
+#
+
+module MissManners
+  class MannersData    
+    def initialize
+      @guests16 = [
+        Guest.new(:n1, :f, :h3),
+        Guest.new(:n1, :f, :h1),
+        Guest.new(:n1, :f, :h2),
+        Guest.new(:n2, :f, :h3),
+        Guest.new(:n2, :f, :h2),
+        Guest.new(:n3, :m, :h1),
+        Guest.new(:n3, :m, :h3),
+        Guest.new(:n4, :m, :h2),
+        Guest.new(:n4, :m, :h1),
+        Guest.new(:n5, :m, :h2),
+        Guest.new(:n5, :m, :h3),
+        Guest.new(:n6, :m, :h2),
+        Guest.new(:n6, :m, :h1),
+        Guest.new(:n7, :f, :h2),
+        Guest.new(:n7, :f, :h1),
+        Guest.new(:n7, :f, :h3),
+        Guest.new(:n8, :f, :h3),
+        Guest.new(:n8, :f, :h2),
+        Guest.new(:n9, :f, :h1),
+        Guest.new(:n9, :f, :h3),
+        Guest.new(:n9, :f, :h2),
+        Guest.new(:n10, :m, :h2),
+        Guest.new(:n10, :m, :h3),
+        Guest.new(:n11, :m, :h3),
+        Guest.new(:n11, :m, :h2),
+        Guest.new(:n11, :m, :h1),
+        Guest.new(:n12, :m, :h3),
+        Guest.new(:n12, :m, :h1),
+        Guest.new(:n13, :m, :h2),
+        Guest.new(:n13, :m, :h3),
+        Guest.new(:n13, :m, :h1),
+        Guest.new(:n14, :f, :h3),
+        Guest.new(:n14, :f, :h1),
+        Guest.new(:n15, :f, :h3),
+        Guest.new(:n15, :f, :h2),
+        Guest.new(:n15, :f, :h1),
+        Guest.new(:n16, :f, :h3),
+        Guest.new(:n16, :f, :h2),
+        Guest.new(:n16, :f, :h1),
+        LastSeat.new(16)]
+        
+      @guests32 = [
+        Guest.new(:n1, :m, :h1),
+        Guest.new(:n1, :m, :h3),
+        Guest.new(:n2, :f, :h3),
+        Guest.new(:n2, :f, :h2),
+        Guest.new(:n2, :f, :h1),
+        Guest.new(:n3, :f, :h1),
+        Guest.new(:n3, :f, :h2),
+        Guest.new(:n4, :f, :h3),
+        Guest.new(:n4, :f, :h1),
+        Guest.new(:n5, :f, :h1),
+        Guest.new(:n5, :f, :h2),
+        Guest.new(:n6, :m, :h1),
+        Guest.new(:n6, :m, :h2),
+        Guest.new(:n6, :m, :h3),
+        Guest.new(:n7, :f, :h2),
+        Guest.new(:n7, :f, :h1),
+        Guest.new(:n7, :f, :h3),
+        Guest.new(:n8, :f, :h1),
+        Guest.new(:n8, :f, :h3),
+        Guest.new(:n8, :f, :h2),
+        Guest.new(:n9, :f, :h1),
+        Guest.new(:n9, :f, :h3),
+        Guest.new(:n9, :f, :h2),
+        Guest.new(:n10, :m, :h2),
+        Guest.new(:n10, :m, :h1),
+        Guest.new(:n11, :m, :h2),
+        Guest.new(:n11, :m, :h1),
+        Guest.new(:n12, :m, :h3),
+        Guest.new(:n12, :m, :h2),
+        Guest.new(:n13, :m, :h1),
+        Guest.new(:n13, :m, :h3),
+        Guest.new(:n14, :m, :h3),
+        Guest.new(:n14, :m, :h2),
+        Guest.new(:n15, :f, :h2),
+        Guest.new(:n15, :f, :h1),
+        Guest.new(:n15, :f, :h3),
+        Guest.new(:n16, :f, :h3),
+        Guest.new(:n16, :f, :h2),
+        Guest.new(:n16, :f, :h1),
+        Guest.new(:n17, :m, :h3),
+        Guest.new(:n17, :m, :h2),
+        Guest.new(:n18, :f, :h2),
+        Guest.new(:n18, :f, :h1),
+        Guest.new(:n19, :f, :h1),
+        Guest.new(:n19, :f, :h2),
+        Guest.new(:n19, :f, :h3),
+        Guest.new(:n20, :f, :h1),
+        Guest.new(:n20, :f, :h2),
+        Guest.new(:n20, :f, :h3),
+        Guest.new(:n21, :m, :h2),
+        Guest.new(:n21, :m, :h3),
+        Guest.new(:n21, :m, :h1),
+        Guest.new(:n22, :f, :h1),
+        Guest.new(:n22, :f, :h2),
+        Guest.new(:n22, :f, :h3),
+        Guest.new(:n23, :f, :h3),
+        Guest.new(:n23, :f, :h1),
+        Guest.new(:n23, :f, :h2),
+        Guest.new(:n24, :m, :h1),
+        Guest.new(:n24, :m, :h3),
+        Guest.new(:n25, :f, :h3),
+        Guest.new(:n25, :f, :h2),
+        Guest.new(:n25, :f, :h1),
+        Guest.new(:n26, :f, :h3),
+        Guest.new(:n26, :f, :h2),
+        Guest.new(:n26, :f, :h1),
+        Guest.new(:n27, :m, :h3),
+        Guest.new(:n27, :m, :h1),
+        Guest.new(:n27, :m, :h2),
+        Guest.new(:n28, :m, :h3),
+        Guest.new(:n28, :m, :h1),
+        Guest.new(:n29, :m, :h3),
+        Guest.new(:n29, :m, :h2),
+        Guest.new(:n29, :m, :h1),
+        Guest.new(:n30, :m, :h2),
+        Guest.new(:n30, :m, :h1),
+        Guest.new(:n30, :m, :h3),
+        Guest.new(:n31, :m, :h2),
+        Guest.new(:n31, :m, :h1),
+        Guest.new(:n32, :m, :h1),
+        Guest.new(:n32, :m, :h3),
+        Guest.new(:n32, :m, :h2),
+        LastSeat.new(32)]
+    end
+    
+    attr_reader :guests16
+    attr_reader :guests32
+  end
+end

data/benchmarks/miss_manners/miss_manners.rb

@@ -0,0 +1,33 @@
+# This file is part of the Ruleby project (http://ruleby.org)
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# LICENSE.txt file.
+# 
+# Copyright (c) 2007 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner, Matt Smith
+#
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '../../lib/')
+require 'ruleby'
+require 'model'
+require 'data'
+require 'rules'
+
+include Ruleby
+include MissManners
+
+t1 = Time.new
+engine :e do |e|     
+  MannersRulebook.new(e).rules
+  MannersData.new.guests16.each do |g|
+    e.assert g
+  end  
+  e.assert Context.new(:start)
+  e.assert Count.new(1)  
+  e.match
+end
+t2 = Time.new
+diff = t2.to_f - t1.to_f
+puts diff.to_s

data/benchmarks/miss_manners/model.rb

@@ -0,0 +1,193 @@
+# This file is part of the Ruleby project (http://ruleby.org)
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# LICENSE.txt file.
+# 
+# Copyright (c) 2007 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner, Matt Smith
+#
+
+module MissManners
+
+  class Chosen
+    def initialize(id,guestName,hobby)
+      @id = id
+      @guestName = guestName
+      @hobby = hobby
+    end
+    attr_reader :id, :guestName, :hobby
+    def to_s
+      "{Chosen id=#{@id}, name=#{@guestName}, hobbies=#{@hobby}}"
+    end
+  end
+  
+  class Context
+    START_UP      = 0
+    ASSIGN_SEATS  = 1
+    MAKE_PATH     = 2
+    CHECK_DONE    = 3
+    PRINT_RESULTS = 4
+    STATE_STRINGS = ["START_UP","ASSIGN_SEATS","MAKE_PATH","CHECK_DONE","PRINT_RESULTS"]
+    def initialize(state)
+      if state == :start
+        @state = START_UP
+      else
+        raise "Context #{state.to_s} does not exist for Context Enum"
+      end
+    end
+    attr :state, true
+    def string_value
+      return STATE_STRINGS[@state]
+    end
+    def is_state(state)
+      return @state == state
+    end
+    def to_s
+      return "[Context state=" + string_value.to_s + "]";
+    end
+  end
+  
+  class Count
+    def initialize(value)
+      @value = value
+    end
+    attr :value, true
+    def ==(object)
+      if object.object_id == self.object_id
+        return true
+      elsif object == nil || !(object.kind_of?(Count))
+        return false
+      end
+      return @value == object.value;
+    end
+    def to_s
+      return "[Count value=#{@value.to_s}]"
+    end
+    def to_hash
+      return value.to_hash
+    end
+  end
+  
+  class Guest
+    def initialize(name,sex,hobby)
+      @name = name
+      @sex = sex
+      @hobby = hobby
+    end
+    attr_reader :name,:sex,:hobby
+    def to_s
+      return "[Guest name=" + @name.to_s + ", sex=" + @sex.to_s + ", hobbies=" + @hobby.to_s + "]";
+    end
+  end
+  
+  class Hobby
+    @stringH1 = "h1"
+    @stringH2 = "h2"
+    @stringH3 = "h3"
+    @stringH4 = "h4"
+    @stringH5 = "h5"
+    HOBBY_STRINGS = [@stringH1,@stringH2,@stringH3,@stringH4,@stringH5]  
+    def initialize(hobby)
+      @hobbyIndex = hobby-1
+      @hobby = HOBBY_STRINGS[@hobbyIndex]
+    end
+    H1 = Hobby.new(1)
+    H2 = Hobby.new(2)
+    H3 = Hobby.new(3)
+    H4 = Hobby.new(4)
+    H5 = Hobby.new(5)
+    attr_reader :hobby
+    def resolve(hobby)
+      if @stringH1 == hobby 
+        return H1
+      elsif @stringH2 == hobby 
+        return H2
+      elsif @stringH3 == hobby 
+        return H3
+      elsif @stringH4 == hobby 
+        return H4
+      elsif @stringH5 == hobby  
+        return H5
+      else 
+        raise "Hobby '" + @hobby.to_s + "' does not exist for Hobby Enum" 
+      end
+    end
+    def to_hash
+      return @hobbyIndex.to_hash
+    end
+    def to_s
+      return @hobby
+    end
+  end
+  
+  class LastSeat
+    def initialize(seat)
+      @seat = seat
+    end
+    attr_reader :seat
+    def to_s
+      return "[LastSeat seat=#{@seat.to_s}]"
+    end
+  end
+  
+  class Path
+    def initialize(id,seat,guestName)
+      @id = id
+      @guestName = guestName
+      @seat = seat
+    end
+    attr_reader :id, :guestName, :seat
+    def to_s
+      "[Path id=#{@id.to_s}, name=#{@guestName.to_s}, seat=#{@seat.to_s}]"
+    end
+  end
+  
+  class Seating
+    def initialize(id,pid,path,leftSeat,leftGuestName,rightSeat,rightGuestName)
+      @id = id
+      @pid = pid
+      @path = path
+      @leftSeat = leftSeat
+      @leftGuestName = leftGuestName
+      @rightSeat = rightSeat
+      @rightGuestName = rightGuestName
+    end
+    attr :path, true
+    attr_reader :id,:pid,:leftSeat,:leftGuestName,:rightSeat,:rightGuestName
+    def to_s
+      return "[Seating id=#{@id.to_s} , pid=#{pid.to_s} , pathDone=#{@path.to_s} , leftSeat=#{@leftSeat.to_s}, leftGuestName=#{@leftGuestName.to_s}, rightSeat=#{@rightSeat.to_s}, rightGuestName=#{@rightGuestName.to_s}]";
+    end
+  end
+  
+  class Sex  
+    STRING_M = 'm'
+    STRING_F = 'f'
+    SEX_LIST = [ STRING_M, STRING_F ]
+    def initialize(sex)
+      @sex = sex
+    end
+    M = Sex.new( 0 )
+    F = Sex.new( 1 )
+    def sex
+      return SEX_LIST[sex]
+    end
+    def resolve(sex) 
+      if STRING_M == sex 
+        return M
+      elsif STRING_F == sex 
+        return F
+      else 
+        raise "Sex '#{@sex.to_s}' does not exist for Sex Enum" 
+      end
+    end
+    def to_s
+      return @sex.to_s
+    end
+    def to_hash
+      return @sex.to_hash
+    end
+  end
+
+end

data/benchmarks/miss_manners/rules.rb

@@ -0,0 +1,105 @@
+# This file is part of the Ruleby project (http://ruleby.org)
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# LICENSE.txt file.
+# 
+# Copyright (c) 2007 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner, Matt Smith
+#
+
+require 'model'
+
+module MissManners
+
+class MannersRulebook < Ruleby::Rulebook
+  def rules
+    rule :assignFirstSeat, 
+      [Context,:context, m.state == Context::START_UP], 
+      [Guest,:guest],
+      [Count,:count] do |vars|         
+        guestName = vars[:guest].name        
+        seating =  Seating.new(vars[:count].value,1,true,1,guestName,1,guestName)
+        assert seating        
+        path = Path.new(vars[:count].value, 1, guestName)
+        assert path
+        retract vars[:count]
+        vars[:count].value = vars[:count].value + 1         
+        assert vars[:count]
+	      puts "assign first seat :  #{seating.to_s} : #{path.to_s}"
+        vars[:context].state = Context::ASSIGN_SEATS        
+        modify vars[:context]  
+    end
+    
+    rule :findSeating, 
+      [Context,:context, {m.state == Context::ASSIGN_SEATS => :state}],
+      [Count,:count, {m.value => :countValue}],       
+      [Seating,:seating, {m.path ==  true =>:p, m.id=>:seatingId, m.pid=>:seatingPid, m.rightSeat=>:seatingRightSeat,  m.rightGuestName=>:seatingRightGuestName}],
+      [Guest,:g, {m.name=>:name, m.sex=>:rightGuestSex, m.hobby=>:rightGuestHobby}, m.name == b(:seatingRightGuestName)],
+      [Guest,:lg, {m.name=>:leftGuestName, m.sex=>:sex, m.hobby == b(:rightGuestHobby) => :hobby}, m.sex(:rightGuestSex, &c{|s,rgs| s != rgs} )],         
+      [:~,Path, m.id == b(:seatingId), m.guestName == b(:leftGuestName)],
+      [:~,Chosen, m.id == b(:seatingId), m.guestName == b(:leftGuestName), m.hobby == b(:leftGuestHobby)] do |vars|         
+        rightSeat = vars[:seatingRightSeat]
+        seatId = vars[:seatingId]
+        countValue = vars[:count].value               
+        seating = Seating.new(countValue,seatId,false,rightSeat,vars[:seatingRightGuestName],rightSeat+1,vars[:leftGuestName])        
+        path = Path.new(countValue,rightSeat+1,vars[:leftGuestName])
+        chosen = Chosen.new(seatId, vars[:leftGuestName], vars[:rightGuestHobby] )     
+  	    puts "find seating : #{seating} : #{path} : #{chosen}"
+  	    assert seating 
+  	    assert path
+  	    assert chosen
+        vars[:count].value = countValue + 1
+        modify vars[:count]
+        vars[:context].state = Context::MAKE_PATH
+        modify vars[:context]    
+    end
+    
+    rule :makePath, 
+      [Context,:context, {m.state == Context::MAKE_PATH => :s}],
+      [Seating,:seating, {m.id=>:seatingId, m.pid=>:seatingPid, m.path == false =>:p}],
+      [Path,:path, {m.guestName=>:pathGuestName, m.seat=>:pathSeat}, m.id == b(:seatingPid)],
+      [:~,Path,m.id == b(:seatingId), m.guestName == b(:pathGuestName)] do |vars|
+        path = Path.new(vars[:seatingId],vars[:pathSeat],vars[:pathGuestName])        
+        assert path
+        puts "make Path : #{path}"    
+    end
+    
+    # NOTE We had to add the priority because Ruleby's conflict resolution strategy
+    # is not robust enough.  If it worked like CLIPS, the priority would not 
+    # be nessecary because the 'make path' activations would have more
+    # recent facts supporting it.  This is really an error in the Miss Manners
+    # benchmark, so it is not considered cheating.
+    rule :pathDone, {:priority => -5},
+      [Context,:context, m.state == Context::MAKE_PATH],
+      [Seating,:seating, m.path == false] do |vars|
+        vars[:seating].path = true
+        modify vars[:seating]        
+        vars[:context].state = Context::CHECK_DONE
+        modify vars[:context]
+        puts "path Done : #{vars[:seating]}"
+    end
+    
+    rule :areWeDone,
+      [Context,:context, m.state == Context::CHECK_DONE],
+      [LastSeat,:ls, {m.seat => :lastSeat}],
+      [Seating,:seating, m.rightSeat == b(:lastSeat)] do |vars|
+        vars[:context].state = Context::PRINT_RESULTS
+        modify vars[:context]
+    end
+    
+    rule :continue, {:priority => -5},
+      [Context,:context,m.state == Context::CHECK_DONE] do |vars|
+        vars[:context].state = Context::ASSIGN_SEATS
+        modify vars[:context]
+    end
+    
+    rule :allDone,
+      [Context,:context,m.state == Context::PRINT_RESULTS] do |vars|
+        puts 'All done'
+    end
+  end
+end
+
+end