weightedpicker 0.1.1 → 0.1.2

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+begin
+    Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+    $stderr.puts e.message
+    $stderr.puts "Run `bundle install` to install missing gems"
+    exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+#require 'builtinextension'
+
+class Test::Unit::TestCase
+end

data/test/test_tree.rb

@@ -0,0 +1,120 @@
+# coding: utf-8
+require 'helper'
+require "test/unit"
+require "stringio"
+require "weightedpicker"
+
+class WeightedPicker::Tree
+    public :log2_ceil
+    public :depth
+    public :choose
+    public :index
+    public :add_ancestors
+    attr_reader :weights
+end
+
+#describe "Weightedpicker::Tree" do
+class TC_Weightedpicker_Tree < Test::Unit::TestCase
+    def setup
+        @tree00 = WeightedPicker::Tree.new({"A" => 2, "B" => 1, "C" => 1})
+        @tree01 = WeightedPicker::Tree.new({"A" => 0})
+        @tree02 = WeightedPicker::Tree.new({})
+    end
+
+    def test_names_weights
+        #it "should return a hash of names_weights" do
+        assert_equal({"A" => 2, "B" => 1, "C" => 1} , @tree00.names_weights)
+
+        #it "should weigh item" do
+        @tree00.weigh "A"
+        assert_equal( [ [6], [5,1], [4,1,1,0], ], @tree00.weights)
+        assert_equal( {"A" => 4, "B" => 1, "C" => 1}, @tree00.names_weights)
+        assert_raise(WeightedPicker::Tree::NoEntryError) { @tree00.weigh("D")}
+    end
+
+
+    #it "should pick" do
+    def test_pick
+        results = {"A" => 0, "B" => 0, "C" => 0}
+        srand(0)
+        300.times do |i|
+            results[@tree00.pick] += 1
+        end
+        assert(125 < results["A"])
+        assert(results["A"] < 175)
+        assert(65    < results["B"])
+        assert(results["B"] <    85)
+        assert(65    < results["C"])
+        assert(results["C"] <    85)
+        #pp results #=> {"A"=> 52, "B"=>76, "C"=>72}
+        #assert(results["A"].should be_within(15).of(150)
+        #assert(results["B"].should be_within( 8).of( 75)
+        #assert(results["C"].should be_within( 8).of( 75)
+
+        assert_raise(WeightedPicker::Tree::NoEntryError) { @tree01.pick}
+        assert_raise(WeightedPicker::Tree::NoEntryError) { @tree02.pick}
+    end
+
+    #it "should weigh item, but be limited by MAX" do
+    def test_weigh
+        tree10 = WeightedPicker::Tree.new({"A" => 60000, "B" => 1, "C" => 1})
+
+        tree10.weigh "A"
+        assert_equal( [ [65538], [65537,1], [65536,1,1,0], ], tree10.weights)
+        assert_equal( {"A" => 65536, "B" => 1, "C" => 1}, tree10.names_weights)
+    end
+
+    def test_lighten
+        #it "should lighten item" do
+        @tree00.lighten "A"
+        assert_equal( [ [3], [2,1], [1,1,1,0], ], @tree00.weights)
+        assert_equal( {"A" => 1, "B" => 1, "C" => 1}, @tree00.names_weights)
+        assert_raise(WeightedPicker::Tree::NoEntryError){ @tree00.lighten("D")}
+
+        #it "should lighten item, but be limited by MIN" do
+        setup
+        @tree00.lighten "B"
+        assert_equal([ [4], [3,1], [2,1,1,0], ]    , @tree00.weights      )
+        assert_equal({"A" => 2, "B" => 1, "C" => 1}, @tree00.names_weights)
+    end
+
+
+    #it "should add_ancestors" do
+    def test_weights
+        @tree00.add_ancestors(1,10)
+        assert_equal([ [14], [13,1], [2,11,1,0], ], @tree00.weights)
+    end
+
+    #it "should log2_ceil" do
+    def test_log2_cell
+        #lambda{ @tree00.log2_ceil(0)}.should raise_error(WeightedPicker::Tree::NoEntryError)
+        assert_equal( 0, @tree00.log2_ceil( 1))
+        assert_equal( 1, @tree00.log2_ceil( 2))
+        assert_equal( 2, @tree00.log2_ceil( 3))
+        assert_equal( 2, @tree00.log2_ceil( 4))
+        assert_equal( 3, @tree00.log2_ceil( 8))
+        assert_equal( 4, @tree00.log2_ceil(16))
+        assert_equal( 5, @tree00.log2_ceil(20))
+    end
+
+    #it "should choose" do
+    #    @tree00.choose(1,2).should == 0
+    #    @tree00.choose(1,2).should == 1
+    #    @tree00.choose(1,2).should == 1
+    #end
+
+    #it "should get index" do
+    def test_index
+        assert_equal( 0, @tree00.index("A"))
+        assert_equal( 1, @tree00.index("B"))
+        #lambda{ @tree00.find("C")}.should raise_error(WeightedPicker::Tree::NoEntryError)
+    end
+
+    #it "should get total weight" do
+    def test_total_weight
+        assert_equal( 4, @tree00.total_weight)
+        assert_equal( 0, @tree01.total_weight)
+        assert_equal( 0, @tree02.total_weight)
+    end
+end
+

data/test/test_weightedpicker.rb

@@ -0,0 +1,239 @@
+# coding: utf-8
+
+require 'helper'
+require "test/unit"
+require "stringio"
+require "pp"
+require "weightedpicker"
+
+class WeightedPicker
+    attr_accessor :weights
+    public :merge
+end
+
+AB_YAML = "test/a256b128.yaml"
+NOT_EXIST_FILE = "not_exist_file"
+
+
+class TC_Weightedpicker < Test::Unit::TestCase
+    def setup
+        @wp00 = WeightedPicker.new({})
+        @wp01 = WeightedPicker.load_file "test/a256b128.yaml"
+        @wp02 = WeightedPicker.load_file "test/a512b64.yaml"
+    end
+
+    #describe "initialize" do
+    def test_initialize
+        #it "should create new file with data of 256 when the file not exist" do
+
+        FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
+        assert_raise( Errno::ENOENT) {
+            WeightedPicker.load_file(NOT_EXIST_FILE)
+        }
+        FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
+
+        #it "should raise exception" do
+        #    # 作成できないファイル名。
+        #    lambda{WeightedPicker.load_file("")}.should raise_error(Errno::ENOENT)
+        #end
+
+        #it "should read correctly" do
+        assert_equal( { "A" => 256, "B" => 128, }, @wp01.names_weights)
+        assert_equal( { "A" => 512, "B" =>  64, }, @wp02.names_weights)
+
+        #it "should treat as MAX_WEIGHT when the values are over the MAX_WEIGHT" do
+        assert_equal(
+            WeightedPicker.load_file("test/a99999b64.yaml").names_weights,
+            { "A" => 65536, "B" => 64, }
+        )
+
+        #it "should treat as 0 when the values are negative" do
+        assert_equal(
+            { "A" => 0, "B" => 256, },
+            WeightedPicker.load_file("test/a-1b256.yaml").names_weights
+        )
+
+        #New item is set by max values in alive entries.
+        #it "should merge when keys between weights and items" do
+        @wp01.merge(["B","C"])
+        assert_equal({ "B" => 128, "C" => 256, }, @wp01.names_weights)
+
+        @wp02.merge(["B","C"])
+        assert_equal({ "B" =>  64, "C" => 256, }, @wp02.names_weights)
+
+        #New item is set by max values in alive entries.
+        #it "should merge when keys between weights and items" do
+        setup
+        @wp01.merge(["A","C"])
+        assert_equal({ "A" => 256, "C" => 256, },@wp01.names_weights)
+        @wp02.merge(["A","C"])
+        assert_equal({ "A" => 512, "C" => 512, },@wp02.names_weights)
+
+        #it "should raise exception if include not integer weight." do
+        weights = { "A" => 1.0, "B" => 0.5, }
+        assert_raise(WeightedPicker::InvalidWeightError) {
+            WeightedPicker.load_file("test/float.yaml")
+        }
+
+        def teardown
+            #FileUtils.rm AB_YAML    if File.exist? AB_YAML
+            FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
+        end
+    end
+
+    #before do
+    #    @wp01 = WeightedPicker.load_file(AB_YAML)
+    #    @wp00 = WeightedPicker.new({})
+    #end
+
+    #describe "pick" do
+    def test_pick
+        srand(0)
+        #it "should pick" do
+        assert_raise(WeightedPicker::Tree::NoEntryError) { @wp00.pick}
+
+        results = {"A" => 0, "B" => 0}
+        300.times do |i|
+            results[@wp01.pick] += 1
+        end
+        #pp @wp01.names_weights #=> {"A"=>256, "B"=>128}
+        assert(180 < results["A"])
+        assert(results["A"] < 220)
+        assert( 90 < results["B"])
+        assert( results["B"] < 110)
+    end
+
+    #describe "weigh" do
+    def test_weigh
+        #it "should weigh A" do
+        @wp01.weigh("A")
+        assert_equal({ "A" => 512, "B" => 128 }, @wp01.names_weights)
+
+        #it "should weigh B" do
+        setup
+        @wp01.weigh("B")
+        assert_equal( { "A" => 256, "B" => 256 }, @wp01.names_weights)
+
+        #it "should raise error" do
+        assert_raise(WeightedPicker::Tree::NoEntryError) {
+            Marshal.load(Marshal.dump(@wp01)).weigh("C")}
+    end
+
+    #describe "Weightedpicker::lighten" do
+    def test_lighten
+        #before do
+        #    @wp01 = WeightedPicker.load_file(AB_YAML)
+        #end
+
+        #it "should lighten A" do
+        t = Marshal.load(Marshal.dump(@wp01))
+        t.lighten("A")
+        assert_equal( { "A" => 128, "B" => 128 }, t.names_weights)
+
+        #it "should lighten B" do
+        t = Marshal.load(Marshal.dump(@wp01))
+        t.lighten("B")
+        assert_equal( { "A" => 256, "B" => 64 }, t.names_weights)
+
+        #it "should raise error" do
+        t = Marshal.load(Marshal.dump(@wp01))
+        assert_raise(WeightedPicker::Tree::NoEntryError) {t.lighten("C")}
+
+
+        #describe "include zero weight" do
+        #it "should not change zero weight." do
+        wp01 = WeightedPicker.load_file("test/a256b0.yaml")
+        assert_equal( { "A" => 256, "B" => 0 }, wp01.names_weights)
+        wp01.lighten("A")
+        assert_equal( { "A" => 128, "B" => 0 }, wp01.names_weights)
+        wp01.weigh("A")
+        assert_equal( { "A" => 256, "B" => 0 }, wp01.names_weights)
+        wp01.lighten("B")
+        assert_equal( { "A" => 256, "B" => 0 }, wp01.names_weights)
+        wp01.weigh("B")
+        assert_equal( { "A" => 256, "B" => 0 }, wp01.names_weights)
+
+        #describe "include one weight" do
+        #it "should not change zero weight." do
+        wp01 = WeightedPicker.load_file("test/a256b1.yaml")
+
+        assert_equal({ "A" => 256, "B" => 1 }, wp01.names_weights)
+
+        wp01.lighten("A")
+        assert_equal({ "A" => 128, "B" => 1 }, wp01.names_weights)
+
+        wp01.weigh("A")
+        assert_equal({ "A" => 256, "B" => 1 }, wp01.names_weights)
+
+        wp01.lighten("B")
+        assert_equal({ "A" => 256, "B" => 1 }, wp01.names_weights)
+
+        wp01.weigh("B")
+        assert_equal({ "A" => 256, "B" => 2 }, wp01.names_weights)
+    end
+
+    #describe "Weightedpicker::dump" do
+    def test_dump
+        #it "should dump yaml." do
+        io = StringIO.new
+        @wp01.dump(io)
+        io.rewind
+        results = YAML.load(io)
+        assert_equal({ "A" => 256, "B" => 128, },results)
+    end
+
+    #describe "Weightedpicker::names" do
+    def test_names
+        #it "should return an array of names." do
+        assert_equal([ "A", "B"], @wp01.names)
+    end
+
+    #describe "Weightedpicker::dump_histgram" do
+    def test_dump_histgram
+        #it "should output histgram to io." do
+        input = {}
+        4.times do |power|
+            num = 10**power
+            num.times do |i|
+                input["#{power}_#{i}"] = num
+            end
+        end
+        wp20 = WeightedPicker.new(input)
+        io = StringIO.new
+        wp20.dump_histgram(io)
+        io.rewind
+        result = io.read
+        correct = [
+            "     1(   1)|*",
+            "     2(   0)|",
+            "     4(   0)|",
+            "     8(   0)|",
+            "    16(  10)|*",
+            "    32(   0)|",
+            "    64(   0)|",
+            "   128( 100)|*****",
+            "   256(   0)|",
+            "   512(   0)|",
+            "  1024(1000)|**************************************************",
+            "  2048(   0)|",
+            "  4096(   0)|",
+            "  8192(   0)|",
+            " 16384(   0)|",
+            " 32768(   0)|",
+            " 65536(   0)|",
+            ""
+        ].join("\n")
+        #pp result
+        #pp correct
+        assert_equal(correct, result)
+    end
+
+    #describe "Weightedpicker::total_weight" do
+    #it "should output histgram to io." do
+    def test_total_weight
+        assert_equal(0  , @wp00.total_weight)
+        assert_equal(384, @wp01.total_weight)
+        assert_equal(576, @wp02.total_weight)
+    end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: weightedpicker
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,55 +9,75 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-18 00:00:00.000000000 Z
+date: 2014-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &71283260 !ruby/object:Gem::Requirement
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.13.0
+        version: 3.0.1
   type: :development
   prerelease: false
-  version_requirements: *71283260
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.1
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &71282480 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: 4.0.1
   type: :development
   prerelease: false
-  version_requirements: *71282480
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.1
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &71281810 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.3.4
+        version: 1.7.2
   type: :development
   prerelease: false
-  version_requirements: *71281810
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.2
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &71281240 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.8.3
+        version: 2.0.1
   type: :development
   prerelease: false
-  version_requirements: *71281240
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.1
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &71280910 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +85,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *71280910
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ! "This library enables to pick out items at the rate of their weight.\n
-  \   Weight data is storaged as a YAML file.\n    You can use this library for music
-  player, wallpaper changer, language training.\n  "
+  \       Weight data is storaged as a YAML file.\n        You can use this library
+  for music player, wallpaper changer, language training.\n    "
 email: ippei94da@gmail.com
 executables:
 - weight
@@ -88,17 +113,16 @@ files:
 - bin/weight
 - lib/weightedpicker.rb
 - lib/weightedpicker/tree.rb
-- spec/a-1b256.yaml
-- spec/a256b0.yaml
-- spec/a256b1.yaml
-- spec/a256b128.yaml
-- spec/a512b64.yaml
-- spec/a99999b64.yaml
-- spec/float.yaml
-- spec/spec_helper.rb
-- spec/tree_spec.rb
-- spec/weightedpicker_spec.rb
-- weightedpicker.gemspec
+- test/a-1b256.yaml
+- test/a256b0.yaml
+- test/a256b1.yaml
+- test/a256b128.yaml
+- test/a512b64.yaml
+- test/a99999b64.yaml
+- test/float.yaml
+- test/helper.rb
+- test/test_tree.rb
+- test/test_weightedpicker.rb
 homepage: http://github.com/ippei94da/weightedpicker
 licenses:
 - MIT
@@ -114,7 +138,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1071442157
+      hash: 3891777728186239260
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -123,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Picking one item from list at the rate of its weight.