rkneufeld-fuzzy-realty 0.5.1 → 0.6.2

data/README.rdoc

@@ -1,6 +1,6 @@
 = fuzzy-realty
 
-Description goes here.
+A Fuzzy-search gem for a Real Estate website
 
 == Copyright
 

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
-:minor: 5
-:patch: 1
+:minor: 6
+:patch: 2

data/lib/classes.rb

@@ -1,22 +1,31 @@
 module FuzzyRealty
-  # Stub for testing without Rails project
-  class Listing
-    attr_accessor :price, :sqft, :location, :style
-    def initialize(values={})
-      values.each_key {|k| instance_variable_set(:"@#{k}", values[k])}
-    end
-  end
   class Query
     attr_reader :params
     def initialize(params=[])
+      if params.any? {|param| !param.is_a?(Parameter)}
+        raise "Attempting to add non-Parameter to Query"
+      end
       @params = params
     end
+    # Allows formation of Query by 'popping' parameters onto it
     def << (param)
       if !param.is_a?(Parameter)
         raise "Attempting to add non-Parameter to Query" 
       end
       @params << param
+    end
 
+    # Create a random query for testing
+    def self.random
+      query = Query.new
+      query << Parameter.new(:price, 20_000 + rand(250_000),  [true,false][rand(1)])
+      query << Parameter.new(:sqft,  300 + rand(2000),        [true,false][rand(1)])
+      query << Parameter.new(:location, %W{A B C D}[rand(4)], [true,false][rand(1)])
+      query << Parameter.new(
+        :style,   
+        %W{Bungalow Bi-level Split-level Two-story Condominium}[rand(5)],
+        [true,false][rand(1)])
+      query
     end
   end
   
@@ -30,12 +39,32 @@ module FuzzyRealty
       @desired  = desired
       @required = required
     end
+    
+    #A valid type is any of the ones there is a weight for.
     def self.valid_types
       FuzzyRealty::WEIGHTS.each_key.to_a
     end
+
+  end
+
+  # Stub for testing without Rails project
+  class Listing
+    attr_accessor :price, :sqft, :location, :style
+    def initialize(values={})
+      values.each_key {|k| instance_variable_set(:"@#{k}", values[k])}
+    end
+    def self.random
+      FuzzyRealty::Listing.new({
+        :price => 20_000 + rand(250_000),
+        :sqft => 300 + rand(2000),
+        :location => %W{A B C D}[rand(4)],
+        :style => %W{Bungalow Bi-level Split-level Two-story Condominium}[rand(5)]
+      })
+    end
   end
 end
 
+#Small hack to the Array class to allow for easier type checking
 class Array
   def contains(value)
     self.any? {|array_value| array_value == value }

data/lib/fuzzy_realty.rb

@@ -1,3 +1,5 @@
+require 'benchmark'
+
 require 'weights.rb'
 require 'classes.rb'
 require 'scores_table.rb'
@@ -26,19 +28,34 @@ module FuzzyRealty
       end
       return scores.sort {|a,b| b[:score] <=> a[:score]}
     end
+    def self.performance
+      puts "Benchmarking search through 100,000-1 (powers of ten) random listings"
+      puts "======================================================================="
+      listings = []
+      100_000.times { listings << Listing.random }
+      puts "Generated #{listings.count} random listings"
+      Benchmark.bm do |x|
+        x.report("100,000 listings:") { ExpertSystem.scores(listings,Query.random) }
+        listings = listings[(0...10_000)]
+        x.report("10,000 listings:") { ExpertSystem.scores(listings,Query.random) }
+        listings = listings[(0...1_000)]
+        x.report("1,000 listings:") { ExpertSystem.scores(listings,Query.random) }
+        listings = listings[(0...100)]
+        x.report("100 listings:") { ExpertSystem.scores(listings,Query.random) }
+        listings = listings[(0...10)]
+        x.report("10 listings:") { ExpertSystem.scores(listings,Query.random) }
+        listings = listings[(0...1)]
+        x.report("1 listing:") { ExpertSystem.scores(listings,Query.random) }
+      end
+    end
   end
 end
 
 #When running the library directly calculate an example
 if __FILE__ == $0
   listings = []
-  100.times do |i|
-    listings << FuzzyRealty::Listing.new({
-      :price => 20_000 + rand(250_000),
-      :sqft => 300 + rand(2000),
-      :location => %W{A B C D}[rand(4)],
-      :style => %W{Bungalow Bi-level Split-level Two-story Condominium}[rand(5)]
-    })
+  1000.times do |i|
+    listings << FuzzyRealty::Listing.random
   end
   
   query  = FuzzyRealty::Query.new
@@ -49,12 +66,13 @@ if __FILE__ == $0
 
   scores = FuzzyRealty::ExpertSystem.scores(listings,query)
   puts "Query 1, $250k Condominium in the prestiguous 'A' suburbs. 1575 sq. ft."
-  puts "Top 20 Listings:"
-  scores[(0..20)].each do |score| 
-    puts "%.2f" % score[:score] + "\t\t#{score[:listing].inspect}"
+  puts "Top 10 Listings:"
+  scores[(0...10)].each_with_index do |score,i| 
+    puts "(#{i+1})\t%.2f" % score[:score] + "\t#{score[:listing].inspect}"
   end
   
   puts "\n"
+  
   query  = FuzzyRealty::Query.new
   query << FuzzyRealty::Parameter.new(:price,99_000,true)
   query << FuzzyRealty::Parameter.new(:location,'C')

data/lib/profiler.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'ruby-prof'
+require 'fuzzy_realty.rb'
+
+RubyProf.start
+
+puts "Generating 10000 Listings"
+listings = []
+10000.times do |i|
+  listings << FuzzyRealty::Listing.random
+end
+
+
+query  = FuzzyRealty::Query.new
+query << FuzzyRealty::Parameter.new(:price,250000)
+query << FuzzyRealty::Parameter.new(:location, 'A',true)
+query << FuzzyRealty::Parameter.new(:style,"Condominium",true)
+query << FuzzyRealty::Parameter.new(:sqft,1575,true)
+
+puts "Running score calculation 10 times..."
+scores = []
+10.times { |i| puts i; scores = FuzzyRealty::ExpertSystem.scores(listings,query) }
+puts "Query 1, $250k Condominium in the prestiguous 'A' suburbs. 1575 sq. ft."
+puts "Top 20 Listings:"
+scores[(0..20)].each do |score| 
+ puts "%.2f" % score[:score] + "\t\t#{score[:listing].inspect}"
+end
+
+puts "\n"
+
+query  = FuzzyRealty::Query.new
+query << FuzzyRealty::Parameter.new(:price,99_000,true)
+query << FuzzyRealty::Parameter.new(:location,'C')
+query << FuzzyRealty::Parameter.new(:style, "Bungalow")
+query << FuzzyRealty::Parameter.new(:sqft,1200)
+
+puts "Running score calculation 10 times..."
+10.times { |i| puts i; scores = FuzzyRealty::ExpertSystem.scores(listings,query) }
+puts "Query 2, $99k Bungalow in the ever so average 'C' block. 1200 sq. ft."
+puts "Top 20 Listings:"
+scores[(0..20)].each do |score| 
+ puts "%.2f" % score[:score] + "\t\t#{score[:listing].inspect}"
+end
+
+result = RubyProf.stop
+
+printer = RubyProf::GraphHtmlPrinter.new(result)
+printer.print(STDOUT, :min_percent=>0)

data/lib/weights.rb

@@ -3,6 +3,9 @@ module FuzzyRealty
   # but as the knowledge engineer I was forced to pick the crisp values. 
   # Experimentation with larger user groups would likely show specific values to do 
   # better 
+  
+  # class Parameter uses this hash to determine what is a valid type. 
+  # - This must be matched by a rule in rulebase.rb
   WEIGHTS = {
     :sqft => 15, 
     :price => 10, 
@@ -10,6 +13,7 @@ module FuzzyRealty
     :style => 18
   }
   
+  # Easy way to sum the max score (for testing)
   def self.max_score
     WEIGHTS.inject(0) {|sum,n| sum + n[1]}
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rkneufeld-fuzzy-realty
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
+  version: 0.6.2
 platform: ruby
 authors: 
 - Ryan Neufeld
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-19 00:00:00 -07:00
+date: 2009-04-20 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -30,6 +30,7 @@ files:
 - lib/TODO
 - lib/classes.rb
 - lib/fuzzy_realty.rb
+- lib/profiler.rb
 - lib/rulebase.rb
 - lib/scores_table.rb
 - lib/weights.rb