bridge 0.1.2 → 0.1.3

data/lib/bridge/constants.rb

@@ -77,7 +77,7 @@ module Bridge
         2500..2990 => 21,
         3000..3490 => 22,
         3500..3990 => 23,
-        4000..7600 => 24
+        4000..15200 => 24
       }
     class Chicago
       # values in array: [not-vulnerable, vulnerable]

data/lib/bridge/points/chicago.rb

@@ -26,16 +26,7 @@ module Bridge::Points
 
     # Returns imps (negative or positive) based on given points
     def imps
-      IMPS.each do |range, imps|
-        return (imps * sign) if range.include?(points_difference.abs)
-      end
-      nil
-    end
-
-    private
-
-    def sign
-      points >= 0 ? 1 : -1
+      Bridge::Points.imps(points_difference)
     end
   end
 end

data/lib/bridge/points/duplicate.rb

@@ -1,29 +1,52 @@
 module Bridge::Points
   class Duplicate
     def initialize(*scores)
-      @scores = Array(scores).flatten
+      @scores = Array(scores).flatten.sort.reverse
     end
 
-    def max
-      @scores.inject({}) do |result, score|
-        result.tap do |r|
-          r[score] ||= @scores.inject(-1) { |points, s| points += (score <=> s) + 1 }
+    def theoretical_maximum
+      (@scores.size - 1) * 2
+    end
+
+    def skipped_scores(number = 1)
+      @scores[number..(-1 - number)]
+    end
+
+    def average_score(number_to_skip = 1)
+      scores = skipped_scores(number_to_skip)
+      (scores.inject(0.0) { |result, score| result += score} / scores.size).round(-1)
+    end
+
+    def maximum
+      {}.tap do |result|
+        @scores.each_with_index do |score, i|
+          result[score] ||= @scores[(i + 1)..-1].inject(0) { |points, s| points += (score <=> s) + 1 }
         end
       end
     end
 
-    # def max_percents
-    #   max.tap do |result|
-    #     result.each do |score, points|
-    #       result[score] = points * 100.0 / theoretical_max
-    #     end
-    #   end
-    # end
+    def maximum_in_percents(precision = 2)
+      maximum.tap do |result|
+        result.each do |score, points|
+          result[score] = (points * 100.0 / theoretical_maximum).round(precision)
+        end
+      end
+    end
 
-    # protected
+    def butler(number_to_skip = 1)
+      {}.tap do |result|
+        @scores.each do |score|
+          result[score] = Bridge::Points.imps(score - average_score(number_to_skip))
+        end
+      end
+    end
 
-    # def theoretical_max
-    #   (@scores.size - 1) * 2
-    # end
+    def cavendish
+      {}.tap do |result|
+        @scores.each do |score|
+          result[score] ||= (@scores.inject(0.0) { |points, s| points += Bridge::Points.imps(score - s) } / (@scores.size - 1)).round(1)
+        end
+      end
+    end
   end
 end

data/lib/bridge/points.rb

@@ -0,0 +1,9 @@
+module Bridge
+  module Points
+    def self.imps(points_difference)
+      sign = (points_difference >= 0) ? 1 : -1
+      IMPS.each { |range, imps| return (imps * sign) if range.include?(points_difference.abs) }
+      nil
+    end
+  end
+end

data/lib/bridge/version.rb

@@ -1,3 +1,3 @@
 module Bridge
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/bridge.rb

@@ -2,6 +2,7 @@ require "bridge/bid"
 require "bridge/card"
 require "bridge/constants"
 require "bridge/deal"
+require "bridge/points"
 require "bridge/points/chicago"
 require "bridge/points/duplicate"
 require "bridge/score"

data/test/test_duplicate.rb

@@ -2,37 +2,72 @@ require "helper"
 
 class TestDuplicate < Test::Unit::TestCase
   test "maximum points with unique values" do
-    max = Bridge::Points::Duplicate.new(-200, -100, 620, 630, 660, 690).max
-    assert_equal 10, max[690]
-    assert_equal  8, max[660]
-    assert_equal  6, max[630]
-    assert_equal  4, max[620]
-    assert_equal  2, max[-100]
-    assert_equal  0, max[-200]
+    maximum = Bridge::Points::Duplicate.new(-200, -100, 620, 630, 660, 690).maximum
+    assert_equal 10, maximum[690]
+    assert_equal  8, maximum[660]
+    assert_equal  6, maximum[630]
+    assert_equal  4, maximum[620]
+    assert_equal  2, maximum[-100]
+    assert_equal  0, maximum[-200]
   end
 
   test "maximum points with non-unique values" do
-    max = Bridge::Points::Duplicate.new(420, 420, 400, 400, -50, -100).max
-    assert_equal 9, max[420]
-    assert_equal 5, max[400]
-    assert_equal 2, max[-50]
-    assert_equal 0, max[-100]
+    maximum = Bridge::Points::Duplicate.new(420, 420, 400, 400, -50, -100).maximum
+    assert_equal 9, maximum[420]
+    assert_equal 5, maximum[400]
+    assert_equal 2, maximum[-50]
+    assert_equal 0, maximum[-100]
   end
 
   test "maximum points with non-unique values, without zero value" do
-    max = Bridge::Points::Duplicate.new(430, 420, 420, 420, 300, 300).max
-    assert_equal 10, max[430]
-    assert_equal  6, max[420]
-    assert_equal  1, max[300]
+    maximum = Bridge::Points::Duplicate.new(430, 420, 420, 420, 300, 300).maximum
+    assert_equal 10, maximum[430]
+    assert_equal  6, maximum[420]
+    assert_equal  1, maximum[300]
   end
 
-  # test "maximum percents" do
-  #   max_percents = Bridge::Points::Duplicate.new(50, 400, 110, 100, 110, 120, 50, 120, 140, 420, 110, 110, 110, 110, 50, 110, 140, 110).max_percents
-  #   notify max_percents.inspect
-  # end
+  test "maximum percents with non-unique values" do
+    maximum_in_percents = Bridge::Points::Duplicate.new(-630, 100, 100, -600, 200, -600, 100, 100, 100, -600, 100, 100, 100, 100).maximum_in_percents(1)
+    assert_equal 100.0, maximum_in_percents[200]
+    assert_equal  61.5, maximum_in_percents[100]
+    assert_equal  15.4, maximum_in_percents[-600]
+    assert_equal   0.0, maximum_in_percents[-630]
+  end
+
+  test "maximum percents with unique-values" do
+    maximum_in_percents = Bridge::Points::Duplicate.new(200, 170, 500, 430, 550, 420).maximum_in_percents(2)
+    assert_equal 100.0, maximum_in_percents[550]
+    assert_equal  80.0, maximum_in_percents[500]
+    assert_equal  60.0, maximum_in_percents[430]
+    assert_equal  40.0, maximum_in_percents[420]
+    assert_equal  20.0, maximum_in_percents[200]
+    assert_equal   0.0, maximum_in_percents[170]
+  end
+
+  test "butler with skipping the highest and the lowest score" do
+    butler = Bridge::Points::Duplicate.new(690, 660, 630, 620, -100, -200).butler
+    assert_equal   6, butler[690]
+    assert_equal   5, butler[660]
+    assert_equal   5, butler[630]
+    assert_equal   5, butler[620]
+    assert_equal -11, butler[-100]
+    assert_equal -12, butler[-200]
+  end
+
+  test "cavendish with unique values" do
+    cavendish = Bridge::Points::Duplicate.new(690, 660, 630, 620, -100, -200).cavendish
+    assert_equal   6.2, cavendish[690]
+    assert_equal   5.4, cavendish[660]
+    assert_equal   4.4, cavendish[630]
+    assert_equal   4.4, cavendish[620]
+    assert_equal  -9.4, cavendish[-100]
+    assert_equal -11.0, cavendish[-200]
+  end
 
-  # test "maximum percents 2" do
-  #   max_percents = Bridge::Points::Duplicate.new(-500, -650, -170, -170, -620, -620, -620).max_percents
-  #   notify max_percents.inspect
-  # end
+  test "cavendish with non-unique values" do
+    cavendish = Bridge::Points::Duplicate.new(100, 100, 110, 140).cavendish
+    assert_equal  1.0, cavendish[140]
+    assert_equal -0.3, cavendish[110]
+    assert_equal -0.3, cavendish[100]
+  end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 2
-  version: 0.1.2
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - "Jakub Ku\xC5\xBAma"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-14 00:00:00 +02:00
+date: 2010-09-15 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -54,6 +54,7 @@ files:
 - lib/bridge/card.rb
 - lib/bridge/constants.rb
 - lib/bridge/deal.rb
+- lib/bridge/points.rb
 - lib/bridge/points/chicago.rb
 - lib/bridge/points/duplicate.rb
 - lib/bridge/score.rb
@@ -82,7 +83,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -4128306614799067572
+      hash: -942411906783919221
       segments: 
       - 0
       version: "0"