weightedpicker 0.0.2 → 0.1.0

data/CHANGES

@@ -1,7 +1,18 @@
-== Master (for 0.0.2)
+= weightedpicker changelog
+
+== Master (for 0.1.1)
+
+== Version 0.1.0
   Use integer alternative to float.
   Add test for 'pick' method.
 
+  WeightedPicker::Tree is added.
+  WeightedPicker::Tree::Node is added.
+
+  Change treatment of values over MAX and under MIN.
+  Change user interface around initialize and merge.
+  Change main weight range to between 2^0 and 2^16.
+
 == Version 0.0.1
   bugfix.
 

data/Gemfile

@@ -6,9 +6,10 @@ source "http://rubygems.org"
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "rspec", "~> 2.9.0"
+  gem "rspec", "~> 2.13.0"
   gem "rdoc", "~> 3.12"
-  gem "bundler", "~> 1.1.3"
+  gem "bundler", "~> 1.3.4"
   gem "jeweler", "~> 1.8.3"
   gem "simplecov", ">= 0"
+  #gem "psych", ">= 0"
 end

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.1.0

data/lib/weightedpicker.rb

@@ -1,5 +1,9 @@
 require 'yaml'
 
+class WeightedPicker; end
+
+require 'weightedpicker/tree.rb'
+
 # TODO
 #   initialize.指定したファイル内のデータが WeightedPicker 的に
 #   解釈できなければ例外。
@@ -91,8 +95,9 @@ require 'yaml'
 # 
 # ヒストリ関係はこのクラスの外に出した方が良いと判断。
 class WeightedPicker
-  MAX_WEIGHT = 1_000_000
-  MIN_WEIGHT = 1
+  MAX_WEIGHT = 2**16
+  INI_WEIGHT = 2** 8
+  MIN_WEIGHT = 2** 0
 
   class InvalidFilenameError < Exception; end
   class NoEntryError         < Exception; end
@@ -100,6 +105,11 @@ class WeightedPicker
   class InvalidWeightError   < Exception; end
 
   # Initialization.
+  def initialize(data)
+    data = sanity_data(data)
+    @tree = WeightedPicker::Tree.new(data)
+  end
+
   # Argument 'file' indicates a strage file name for data
   # which this class manages.
   # If the 'file' does not exist, this file is used to data strage.
@@ -109,109 +119,78 @@ class WeightedPicker
   # A and B in the file and B and C in items,
   # then B and C is the items which this class manage.
   # A is discarded from record.
-  def initialize(file, items)
-    @save_file = file
-    unless File.exist? @save_file
-      File.open(@save_file, "w") {|io| YAML.dump({}, io)}
-    end
-    @weights = YAML.load_file(file)
+  def self.load_file(filename)
+    weights = YAML.load_file(filename)
+    self.new(weights)
+  end
 
-    @weights.values.each do |i|
-      raise InvalidWeightError, "#{i.inspect}, not integer." unless i.is_a? Integer
-    end
+  def dump(io)
+    YAML.dump(@tree.names_weights, io)
+  end
 
-    merge(items)
-    normalize_write
+  def names_weights
+    @tree.names_weights
   end
 
   # 乱数を利用して優先度で重み付けして要素を選び、要素を返す。
   # num is only for test. User should not use this argument.
-  def pick(num = nil)
-    raise NoEntryError if @weights.empty?
-
-    sums = []
-    keys = []
-    sum = 0
-    @weights.each do |key, weight|
-      keys << key
-      sum += weight
-      sums << sum
-    end
-
-    num ||= rand(sum)
-    # find index of first excess a number
-    sums.each_with_index do |item, index|
-      return keys[index] if num < item
-    end
+  def pick
+    @tree.pick
   end
 
   #重みを重くする。(優先度が上がる)
   def weigh(item)
-    #pp @weights
-    raise NotExistKeyError unless @weights.has_key?(item)
-    @weights[ item ] *= 2
-    normalize_write
+    @tree.weigh(item)
   end
 
   #重みを軽くする。(優先度が下がる)
   def lighten(item)
-    raise NotExistKeyError unless @weights.has_key?(item)
-    #@weights[ item ] /= 2 unless @weights[ item ] == 0
-    @weights.each do |key, val|
-      weigh(key) unless key == item
-    end
-    normalize_write
+    @tree.lighten(item)
   end
 
-  ##管理している要素の数を返す。
-  #def size
-  # @weights.size
-  #end
-
-  ##管理している要素と重みでイテレート。
-  ##e.g. ws0.each { |item, weight| p item, weight }
-  ##item が管理しているオブジェクト、weight が重み。
-  #def each
-  # @weights.each do |item, weight|
-  #   yield(item, weight)
-  # end
-  #end
-
-  private
-
   # 引数 keys で示したものと、
   # 内部的に管理しているデータが整合しているかチェックし、
   # keys に合わせる。
-  # 追加されたデータは MAX_WEIGHT の重みとなる。
-  # データが削除された場合、それが最大値の可能性があるので
-  # 必ず normalize_write される。
+  # 追加されたデータの重みは、データ内に存在する最大値と
+  # 同じになる。
+  # This affects destructively.
   def merge(keys)
+    new_weights = {}
+    new_keys = []
+    max = 0
+    data = @tree.names_weights
     keys.each do |key|
-      @weights[key] ||= MAX_WEIGHT
+      new_weights[key] = data[key]
+
+      if data[key] == nil
+        #substitute max among exist values afterward
+        new_keys << key unless data[key]
+        next 
+      end
+
+      max = data[key] if max < data[key]
     end
-    @weights.each do |key, val|
-      @weights.delete(key) unless keys.include?(key)
+
+    max = INI_WEIGHT if max < INI_WEIGHT
+    new_keys.each do |key|
+      new_weights[key] = max
     end
-    #pp @weights
-    #pp keys
-    normalize_write
+
+    data = new_weights
+
+    @tree = WeightedPicker::Tree.new(data)
   end
 
-  # 最大値を max とするように規格化する。
-  # ただし、weight が MIN_WEIGHT 未満となった項目は
-  # MIN_WEIGHT を新しい weight とする。
-  def normalize_write
-    raise NoEntryError if @weights.size == 0
+  private
 
-    old_max = @weights.values.max
-    @weights.each do |key, val|
-      new_val = (val.to_f * (MAX_WEIGHT.to_f / old_max.to_f)).to_i
-      @weights[key] = new_val if MIN_WEIGHT <= new_val
-    end
+  def sanity_data(data)
+    data.each do |key, val|
+      data[key] = 0 if val < MIN_WEIGHT
+      data[key] = MAX_WEIGHT if MAX_WEIGHT < val
 
-    File.open(@save_file, "w") do |io|
-      YAML.dump(@weights, io)
+      raise InvalidWeightError, "#{val.inspect}, not integer." unless val.is_a? Integer
     end
+    data
   end
 
 end

data/lib/weightedpicker/tree.rb

@@ -0,0 +1,139 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#
+#
+#
+class WeightedPicker::Tree
+
+  attr_reader :size
+
+  class NoEntryError < Exception; end
+
+  #
+  def initialize(data)
+    @size = data.size #for return hash.
+
+    @names = data.keys
+    @weights = []
+    @weights[0] = data.values
+
+    #Fill 0 to 2**n
+    @size.upto ((2 ** depth) - 1) do |i|
+      @weights[0][i] = 0
+    end
+
+    depth.times do |i|
+      @weights[i+1] = []
+      num = @weights[i].size
+      (num - num / 2).times do |j|
+        @weights[i+1] << @weights[i][2*j] + @weights[i][2*j + 1]
+      end
+    end
+
+    @weights.reverse!
+  end
+
+  # Return internal data as a Hash.
+  def names_weights
+    results = {}
+    @size.times do |i|
+      results[@names[i]] = @weights[-1][i]
+    end
+    results
+  end
+
+  def pick
+    raise NoEntryError if @weights[0][0] == 0
+
+    current_index = 0
+    depth.times do |i|
+      next_id0 = 2 * current_index
+      next_id1 = 2 * current_index + 1
+      #puts
+      choise = choose( @weights[i+1][next_id0], @weights[i+1][next_id1])
+      current_index = 2 * current_index + choise
+    end
+    return @names[current_index]
+
+
+    #sums = []
+    #keys = []
+    #sum = 0
+    #@weights.each do |key, weight|
+    #  keys << key
+    #  sum += weight
+    #  sums << sum
+    #end
+
+    #num ||= rand(sum)
+    ## find index of first excess a number
+    #sums.each_with_index do |item, index|
+    #  return keys[index] if num < item
+    #end
+  end
+
+  def weigh(item)
+    raise NoEntryError unless @names.include?(item)
+    id = index(item)
+    old_weight = @weights[-1][id]
+    if (WeightedPicker::MAX_WEIGHT < old_weight * 2)
+      add_weight = WeightedPicker::MAX_WEIGHT - old_weight
+    else
+      add_weight = old_weight
+    end
+    return if add_weight == 0
+    add_ancestors(id, add_weight)
+  end
+
+  def lighten(item)
+    raise NoEntryError unless @names.include?(item)
+    id = index(item)
+    old_weight = @weights[-1][id]
+    if (old_weight / 2 < WeightedPicker::MIN_WEIGHT)
+      add_weight = 0
+    else
+      add_weight = - old_weight / 2
+    end
+    return if add_weight == 0
+    add_ancestors(id, add_weight)
+  end
+
+  private
+
+  def add_ancestors(id, val)
+    (depth+1).times do |d|
+      divisor = 2 ** (depth - d)
+      x = id / divisor
+      @weights[d][x] += val
+    end
+  end
+
+  def log2_ceil(num)
+    result = 0
+    while (num > 1)
+      result += 1
+      num -= num/2
+    end
+    result
+  end
+
+  def depth
+    log2_ceil(@size)
+  end
+
+  def choose(num0, num1)
+    sum = num0 + num1
+
+    # 0, 1, 2
+    return 0 if rand(sum) < num0
+    return 1
+  end
+
+  def index(item)
+    return @names.index(item)
+    #raise WeightedPicker::Tree::NoEntryError
+  end
+
+end
+

data/spec/a-1b256.yaml

@@ -0,0 +1,3 @@
+---
+A: -1
+B: 256

data/spec/a256b0.yaml

@@ -0,0 +1,3 @@
+---
+A: 256
+B:   0

data/spec/a256b1.yaml

@@ -0,0 +1,3 @@
+---
+A: 256
+B:   1

data/spec/a256b128.yaml

@@ -0,0 +1,3 @@
+---
+A: 256
+B: 128

data/spec/a512b64.yaml

@@ -0,0 +1,3 @@
+---
+A: 512
+B:  64

data/spec/a99999b64.yaml

@@ -0,0 +1,3 @@
+---
+A: 99999
+B:    64

data/spec/float.yaml

@@ -0,0 +1,3 @@
+---
+A: 1.0
+B: 0.5

data/spec/tree_spec.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require "stringio"
+require "fileutils"
+
+class WeightedPicker::Tree
+  public :log2_ceil
+  public :depth
+  public :choose
+  public :index
+  public :add_ancestors
+  attr_reader :weights
+end
+
+describe "Weightedpicker::Tree" do
+  before do
+    @tree00 = WeightedPicker::Tree.new({"A" => 2, "B" => 1, "C" => 1})
+    @tree01 = WeightedPicker::Tree.new({"A" => 0})
+    @tree02 = WeightedPicker::Tree.new({})
+  end
+
+  it "should do in initialize" do
+    #@tree00
+  end
+
+  it "should return a hash of names_weights" do
+    #@tree00 = WeightedPicker::Tree.new({"A" => 2, "B" => 1, "C" => 1})
+    @tree00.names_weights.should == {"A" => 2, "B" => 1, "C" => 1}
+  end
+
+  it "should pick" do
+    results = {"A" => 0, "B" => 0, "C" => 0}
+    srand(0)
+    300.times do |i|
+      results[@tree00.pick] += 1
+    end
+    #pp results #=> {"A"=> 52, "B"=>76, "C"=>72}
+    results["A"].should be_within(15).of(150)
+    results["B"].should be_within( 8).of( 75)
+    results["C"].should be_within( 8).of( 75)
+
+    lambda{ @tree01.pick}.should raise_error(WeightedPicker::Tree::NoEntryError)
+    lambda{ @tree02.pick}.should raise_error(WeightedPicker::Tree::NoEntryError)
+  end
+
+  it "should weigh item" do
+    @tree00.weigh "A"
+    @tree00.weights.should == [
+      [6],
+      [5,1],
+      [4,1,1,0],
+    ]
+    @tree00.names_weights.should == {"A" => 4, "B" => 1, "C" => 1}
+    lambda{ @tree00.weigh("D")}.should raise_error(WeightedPicker::Tree::NoEntryError)
+  end
+
+  it "should weigh item, but be limited by MAX" do
+    tree10 = WeightedPicker::Tree.new({"A" => 60000, "B" => 1, "C" => 1})
+
+    tree10.weigh "A"
+    tree10.weights.should == [
+      [65538],
+      [65537,1],
+      [65536,1,1,0],
+    ]
+    tree10.names_weights.should == {"A" => 65536, "B" => 1, "C" => 1}
+  end
+
+  it "should lighten item" do
+    @tree00.lighten "A"
+    @tree00.weights.should == [
+      [3],
+      [2,1],
+      [1,1,1,0],
+    ]
+    @tree00.names_weights.should == {"A" => 1, "B" => 1, "C" => 1}
+    lambda{ @tree00.lighten("D")}.should raise_error(WeightedPicker::Tree::NoEntryError)
+  end
+
+  it "should lighten item, but be limited by MIN" do
+    @tree00.lighten "B"
+    @tree00.weights.should == [
+      [4],
+      [3,1],
+      [2,1,1,0],
+    ]
+    @tree00.names_weights.should == {"A" => 2, "B" => 1, "C" => 1}
+  end
+
+
+  it "should add_ancestors" do
+    @tree00.add_ancestors(1,10)
+    @tree00.weights.should == [
+      [14],
+      [13,1],
+      [2,11,1,0],
+    ]
+  end
+
+  it "should log2_ceil" do
+    #lambda{ @tree00.log2_ceil(0)}.should raise_error(WeightedPicker::Tree::NoEntryError)
+    @tree00.log2_ceil( 1).should == 0
+    @tree00.log2_ceil( 2).should == 1
+    @tree00.log2_ceil( 3).should == 2
+    @tree00.log2_ceil( 4).should == 2
+    @tree00.log2_ceil( 8).should == 3
+    @tree00.log2_ceil(16).should == 4
+    @tree00.log2_ceil(20).should == 5
+  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
+    @tree00.index("A").should == 0
+    @tree00.index("B").should == 1
+    #lambda{ @tree00.find("C")}.should raise_error(WeightedPicker::Tree::NoEntryError)
+  end
+
+end
+

data/spec/weightedpicker_spec.rb

@@ -4,357 +4,188 @@ require "fileutils"
 
 class WeightedPicker
   attr_accessor :weights
-  public :normalize_write, :merge
+  public :merge
 end
 
-TMP_FILE = "tmp.yaml"
+AB_YAML = "spec/a256b128.yaml"
 NOT_EXIST_FILE = "not_exist_file"
 
 
 
-describe "Weightedpicker::initialize" do
+describe "Weightedpicker" do
   before do
-    weights = { "A" => 1_000_000, "B" => 500_000, }
-    items = ["A", "B"]
-    File.open(TMP_FILE, "w") { |io| YAML.dump(weights, io) }
-    @wp01 = WeightedPicker.new(TMP_FILE, items)
-    @wp02 = Marshal.load(Marshal.dump(@wp01))
-    @wp02.weights = {}
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
-  end
-
-  it "should create new file when the file not exist" do
-    # 指定したファイルが存在しない場合、
-    t = WeightedPicker.new(NOT_EXIST_FILE, ["A","B"])
-    t.weights.should == { "A" => 1_000_000, "B" => 1_000_000}
-    YAML.load_file(NOT_EXIST_FILE).should == { "A" => 1_000_000, "B" => 1_000_000, }
-  end
-  
-  it "should raise exception" do
-    # 作成できないファイル名。
-    lambda{WeightedPicker.new("", ["A","B"])}.should raise_error(Errno::ENOENT)
-  end
-
-  it "should read correctly" do
-    # 正しく取り込めているか？
-    @wp01.weights.should == { "A" => 1_000_000, "B" => 500_000, }
-  end
-
-  it "should normalize when the maximum in the file not the same as MAX_WEIGHT" do
-    # 指定したファイル内の重みの最大値が MAX_WEIGHT と異なれば、
-    # 全体を normalize して格納。
-    weights = { "A" => 2_000_000, "B" => 500_000, }
-    File.open(TMP_FILE, "w") {|io| YAML.dump(weights, io) }
-    WeightedPicker.new(TMP_FILE, ["A","B"]).weights.should == { "A" => 1_000_000, "B" => 250_000, }
-    #
-    weights = { "A" => 250_000, "B" => 500_000, }
-    File.open(TMP_FILE, "w"){ |io| YAML.dump(weights, io) }
-    WeightedPicker.new(TMP_FILE, ["A","B"]).weights.should == { "A" => 500_000, "B" => 1_000_000, }
-  end
-
-  it "should merge when keys between weights and items" do
-    # weights と items が異なる場合、
-    # まず新しいキーを重み MAX_WEIGHT で追加して、
-    # それから実際にはないキーを削除。
-    weights = { "A" => 1_000_000, "B" => 500_000, }
-    File.open(TMP_FILE, "w") {|io| YAML.dump(weights, io) }
-    #puts "HERE ###################"
-    WeightedPicker.new(TMP_FILE, ["B","C"]).weights.should == { "B" => 500_000, "C" => 1_000_000, }
-  end
-
-  it "should raise exception if include not integer weight." do
-    weights = { "A" => 1.0, "B" => 0.5, }
-    File.open(TMP_FILE, "w") {|io| YAML.dump(weights, io) }
-    lambda{
-      WeightedPicker.new(TMP_FILE, ["A","B"])
-    }.should raise_error(WeightedPicker::InvalidWeightError)
-  end
-
-  after do
-    FileUtils.rm TMP_FILE  if File.exist? TMP_FILE
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
-  end
-
-end
-
-describe "Weightedpicker::merge" do
-  before do
-    weights = { "A" => 1_000_000, "B" => 500_000, }
-    items = ["A", "B"]
-    File.open(TMP_FILE, "w") { |io| YAML.dump(weights, io) }
-    @wp01 = WeightedPicker.new(TMP_FILE, items)
-
-    @wp02 = Marshal.load(Marshal.dump(@wp01))
-    @wp02.weights = {}
-
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
-  end
-
-  it "when keys given are less than weights file" do
-    # 少ない場合
-    t = Marshal.load(Marshal.dump(@wp01))
-    keys = ["B"]
-    t.merge(keys)
-    t.weights. should == { "B" => 1_000_000 }
-    # 書き込みチェック
-    YAML.load_file(TMP_FILE).should == { "B" => 1_000_000 }
-  end
-
-  it "when keys given are more than weights file" do
-    # 多い場合
-    t = Marshal.load(Marshal.dump(@wp01))
-    keys = ["A", "B", "C"]
-    t.merge(keys)
-    t.weights.should == { "A" => 1_000_000, "B" => 500_000, "C" => 1_000_000, }
-    # 書き込みチェック
-    YAML.load_file(TMP_FILE).should == { "A" => 1_000_000, "B" => 500_000, "C" => 1_000_000}
-  end
-
-  it "when keys given are the same as weights file" do
-    t = Marshal.load(Marshal.dump(@wp01))
-    # 同じ場合
-    keys = ["A", "B"]
-    t.merge(keys)
-    t.weights.should == { "A" => 1_000_000, "B" => 500_000}
-    # 書き込みチェック
-    YAML.load_file(TMP_FILE).should == { "A" => 1_000_000, "B" => 500_000}
-  end
-
-  after do
-    FileUtils.rm TMP_FILE  if File.exist? TMP_FILE
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
-  end
-
-end
-
-describe "Weightedpicker::pick" do
-  before do
-    weights = { "A" => 1_000_000, "B" => 500_000, }
-    items = ["A", "B"]
-    File.open(TMP_FILE, "w") { |io| YAML.dump(weights, io) }
-    @wp01 = WeightedPicker.new(TMP_FILE, items)
-
-    @wp02 = Marshal.load(Marshal.dump(@wp01))
-    @wp02.weights = {}
-
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
-  end
+    @wp00 = WeightedPicker.new({})
+    @wp01 = WeightedPicker.load_file "spec/a256b128.yaml"
+    @wp02 = WeightedPicker.load_file "spec/a512b64.yaml"
+  end
+
+  describe "initialize" do
+    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
+      lambda{
+        WeightedPicker.load_file(NOT_EXIST_FILE)
+      }.should raise_error(Errno::ENOENT)
+      FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
+    end
 
-  it "should pick" do
-    lambda{@wp02.pick}.should raise_error(WeightedPicker::NoEntryError)
+    #it "should raise exception" do
+    #  # 作成できないファイル名。
+    #  lambda{WeightedPicker.load_file("")}.should raise_error(Errno::ENOENT)
+    #end
 
-    sum = 1_500_000
-    tryal = 300
-    results = {"A" => 0, "B" => 0}
-    tryal.times do |i|
-      results[@wp01.pick(i * sum / tryal)] += 1
+    it "should read correctly" do
+      # 正しく取り込めているか？
+      @wp01.names_weights.should == { "A" => 256, "B" => 128, }
+      @wp02.names_weights.should == { "A" => 512, "B" =>  64, }
     end
-    results["A"].should == tryal / 3 * 2
-    results["B"].should == tryal / 3 * 1
-  end
 
-  after do
-    FileUtils.rm TMP_FILE  if File.exist? TMP_FILE
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
-  end
+    it "should treat as MAX_WEIGHT when the values are over the MAX_WEIGHT" do
+      #Not write
+      WeightedPicker.load_file("spec/a99999b64.yaml").names_weights.should == { "A" => 65536, "B" => 64, }
+    end
 
-end
+    it "should treat as 0 when the values are negative" do
+      #Not write
+      WeightedPicker.load_file("spec/a-1b256.yaml").names_weights.should == { "A" => 0, "B" => 256, }
+    end
 
-describe "Weightedpicker::weigh" do
-  before do
-    weights = { "A" => 1_000_000, "B" => 500_000, }
-    items = ["A", "B"]
-    File.open(TMP_FILE, "w") { |io| YAML.dump(weights, io) }
-    @wp01 = WeightedPicker.new(TMP_FILE, items)
-    @wp02 = Marshal.load(Marshal.dump(@wp01))
-    @wp02.weights = {}
-
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
-  end
+    #New item is set by max values in alive entries.
+    it "should merge when keys between weights and items" do
+      @wp01.merge(["B","C"])
+      @wp01.names_weights.should == { "B" => 128, "C" => 256, }
+      @wp02.merge(["B","C"])
+      @wp02.names_weights.should == { "B" =>  64, "C" => 256, }
+    end
 
-  it "should weigh A" do
-    t = Marshal.load(Marshal.dump(@wp01))
-    t.weigh("A")
-    t.weights.should == { "A" => 1_000_000, "B" => 250_000 }
-    # 書き込みチェック
-    YAML.load_file(TMP_FILE).should == { "A" => 1_000_000, "B" => 250_000 }
-  end
+    #New item is set by max values in alive entries.
+    it "should merge when keys between weights and items" do
+      @wp01.merge(["A","C"])
+      @wp01.names_weights.should == { "A" => 256, "C" => 256, }
+      @wp02.merge(["A","C"])
+      @wp02.names_weights.should == { "A" => 512, "C" => 512, }
+    end
 
-  it "should weigh B" do
-    t = Marshal.load(Marshal.dump(@wp01))
-    t.weigh("B")
-    t.weights.should == { "A" => 1_000_000, "B" => 1_000_000 }
-    # 書き込みチェック
-    YAML.load_file(TMP_FILE).should == { "A" => 1_000_000, "B" => 1_000_000 }
-  end
+    it "should raise exception if include not integer weight." do
+      weights = { "A" => 1.0, "B" => 0.5, }
+      lambda{
+        WeightedPicker.load_file("spec/float.yaml")
+      }.should raise_error(WeightedPicker::InvalidWeightError)
+    end
 
-  it "should raise error" do
-    lambda{Marshal.load(Marshal.dump(@wp01)).weigh("C")}.should raise_error(WeightedPicker::NotExistKeyError)
+    after do
+      #FileUtils.rm AB_YAML  if File.exist? AB_YAML
+      FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
+    end
   end
 
-  after do
-    FileUtils.rm TMP_FILE  if File.exist? TMP_FILE
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
-  end
+  #before do
+  #  @wp01 = WeightedPicker.load_file(AB_YAML)
+  #  @wp00 = WeightedPicker.new({})
+  #end
 
-end
+  describe "pick" do
+    srand(0)
+    it "should pick" do
+      lambda{@wp00.pick}.should raise_error(WeightedPicker::Tree::NoEntryError)
 
-describe "Weightedpicker::lighten" do
-  before do
-    weights = { "A" => 1_000_000, "B" => 500_000, }
-    items = ["A", "B"]
-    File.open(TMP_FILE, "w") { |io| YAML.dump(weights, io) }
-    @wp01 = WeightedPicker.new(TMP_FILE, items)
-    @wp02 = Marshal.load(Marshal.dump(@wp01))
-    @wp02.weights = {}
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
+      results = {"A" => 0, "B" => 0}
+      300.times do |i|
+        results[@wp01.pick] += 1
+      end
+      #pp @wp01.names_weights #=> {"A"=>256, "B"=>128}
+      results["A"].should be_within(20).of(200)
+      results["B"].should be_within(10).of(100)
+    end
   end
 
-  it "should lighten A" do
-    t = Marshal.load(Marshal.dump(@wp01))
-    t.lighten("A")
-    t.weights.should == { "A" => 1_000_000, "B" => 1_000_000 }
-    # 書き込みチェック
-    YAML.load_file(TMP_FILE).should == { "A" => 1_000_000, "B" => 1_000_000 }
-  end
+  describe "weigh" do
+    it "should weigh A" do
+      @wp01.weigh("A")
+      @wp01.names_weights.should == { "A" => 512, "B" => 128 }
+    end
 
-  it "should lighten B" do
-    t = Marshal.load(Marshal.dump(@wp01))
-    t.lighten("B")
-    t.weights.should == { "A" => 1_000_000, "B" => 250_000 }
-    # 書き込みチェック
-    YAML.load_file(TMP_FILE).should == { "A" => 1_000_000, "B" => 250_000 }
-  end
+    it "should weigh B" do
+      @wp01.weigh("B")
+      @wp01.names_weights.should == { "A" => 256, "B" => 256 }
+    end
 
-  it "should raise error" do
-    t = Marshal.load(Marshal.dump(@wp01))
-    lambda{t.lighten("C")}.should raise_error(WeightedPicker::NotExistKeyError)
-  end
+    it "should raise error" do
+      lambda{Marshal.load(Marshal.dump(@wp01)).weigh("C")}.should raise_error(WeightedPicker::Tree::NoEntryError)
+    end
 
-  after do
-    FileUtils.rm TMP_FILE  if File.exist? TMP_FILE
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
   end
 
-end
+  describe "Weightedpicker::lighten" do
+    #before do
+    #  @wp01 = WeightedPicker.load_file(AB_YAML)
+    #end
 
-describe "Weightedpicker::normalize_write" do
-  before do
-    weights = { "A" => 1_000_000, "B" => 500_000, }
-    items = ["A", "B"]
-    File.open(TMP_FILE, "w") { |io| YAML.dump(weights, io) }
-    @wp01 = WeightedPicker.new(TMP_FILE, items)
-    @wp02 = Marshal.load(Marshal.dump(@wp01))
-    @wp02.weights = {}
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
-  end
-
-  it "should shrink write" do
-    t = Marshal.load(Marshal.dump(@wp01))
-    t.weights = { "A" => 2_000_000, "B" => 500_000, }
-    t.normalize_write
-    t.weights.should == { "A" => 1_000_000, "B" => 250_000}
-    # 書き込みチェック
-    YAML.load_file(TMP_FILE).should == { "A" => 1_000_000, "B" => 250_000}
-  end
+    it "should lighten A" do
+      t = Marshal.load(Marshal.dump(@wp01))
+      t.lighten("A")
+      t.names_weights.should == { "A" => 128, "B" => 128 }
+    end
 
-  it "should shrink write with 2" do
-    t = Marshal.load(Marshal.dump(@wp01))
-    t.weights = { "A" => 2_000_000, "B" => 2, }
-    t.normalize_write
-    t.weights.should == { "A" => 1_000_000, "B" => 1}
-  end
+    it "should lighten B" do
+      t = Marshal.load(Marshal.dump(@wp01))
+      t.lighten("B")
+      t.names_weights.should == { "A" => 256, "B" => 64 }
+    end
 
-  it "should shrink write with 1" do
-    t = Marshal.load(Marshal.dump(@wp01))
-    t.weights = { "A" => 2_000_000, "B" => 1, }
-    t.normalize_write
-    t.weights.should == { "A" => 1_000_000, "B" => 1}
-  end
+    it "should raise error" do
+      t = Marshal.load(Marshal.dump(@wp01))
+      lambda{t.lighten("C")}.should raise_error(WeightedPicker::Tree::NoEntryError)
+    end
 
-  it "should shrink write with 0" do
-    t = Marshal.load(Marshal.dump(@wp01))
-    t.weights = { "A" => 2_000_000, "B" => 0, }
-    t.normalize_write
-    t.weights.should == { "A" => 1_000_000, "B" => 0}
   end
 
-  it "should expand write" do
-    t = Marshal.load(Marshal.dump(@wp01))
-    t.weights = { "A" => 500_000, "B" => 500_000, }
-    t.normalize_write
-    t.weights.should == { "A" => 1_000_000, "B" => 1_000_000}
-    # 書き込みチェック
-    YAML.load_file(TMP_FILE).should == { "A" => 1_000_000, "B" => 1_000_000}
-  end
+  describe "include zero weight" do
+    it "should not change zero weight." do
+      wp01 = WeightedPicker.load_file("spec/a256b0.yaml")
+      wp01.names_weights.should == { "A" => 256, "B" => 0 }
+      wp01.lighten("A")
+      wp01.names_weights.should == { "A" => 128, "B" => 0 }
+      wp01.weigh("A")
+      wp01.names_weights.should == { "A" => 256, "B" => 0 }
+      wp01.lighten("B")
+      wp01.names_weights.should == { "A" => 256, "B" => 0 }
+      wp01.weigh("B")
+      wp01.names_weights.should == { "A" => 256, "B" => 0 }
+    end
 
-  it "should raise error" do
-    lambda{@wp02.normalize_write}.should raise_error (WeightedPicker::NoEntryError)
   end
 
-  after do
-    FileUtils.rm TMP_FILE  if File.exist? TMP_FILE
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
-  end
+  describe "include one weight" do
+    it "should not change zero weight." do
+      wp01 = WeightedPicker.load_file("spec/a256b1.yaml")
 
-end
+      wp01.names_weights.should == { "A" => 256, "B" => 1 }
 
-describe "include zero weight" do
-  before do
-    weights = { "A" => 1_000_000, "B" => 0, }
-    items = ["A", "B"]
-    File.open(TMP_FILE, "w") { |io| YAML.dump(weights, io) }
-    @wp01 = WeightedPicker.new(TMP_FILE, items)
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
-  end
+      wp01.lighten("A")
+      wp01.names_weights.should == { "A" => 128, "B" => 1 }
 
-  it "should not change zero weight." do
-    @wp01.weights.should == { "A" => 1_000_000, "B" => 0 }
-    @wp01.lighten("A")
-    @wp01.weights.should == { "A" => 1_000_000, "B" => 0 }
-    @wp01.weigh("A")
-    @wp01.weights.should == { "A" => 1_000_000, "B" => 0 }
-    @wp01.lighten("B")
-    @wp01.weights.should == { "A" => 1_000_000, "B" => 0 }
-    @wp01.weigh("B")
-    @wp01.weights.should == { "A" => 1_000_000, "B" => 0 }
-  end
+      wp01.weigh("A")
+      wp01.names_weights.should == { "A" => 256, "B" => 1 }
 
-  after do
-    FileUtils.rm TMP_FILE  if File.exist? TMP_FILE
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
-  end
+      wp01.lighten("B")
+      wp01.names_weights.should == { "A" => 256, "B" => 1 }
 
-end
+      wp01.weigh("B")
+      wp01.names_weights.should == { "A" => 256, "B" => 2 }
+    end
 
-describe "include one weight" do
-  before do
-    weights = { "A" => 1_000_000, "B" => 1, }
-    items = ["A", "B"]
-    File.open(TMP_FILE, "w") { |io| YAML.dump(weights, io) }
-    @wp01 = WeightedPicker.new(TMP_FILE, items)
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
   end
 
-  it "should not change zero weight." do
-    @wp01.weights.should == { "A" => 1_000_000, "B" => 1 }
+  describe "Weightedpicker::dump" do
+    it "should dump yaml." do
+      io = StringIO.new
+      @wp01.dump(io)
+      io.rewind
+      results = YAML.load(io)
+      results.should == { "A" => 256, "B" => 128, }
 
-    @wp01.lighten("A")
-    @wp01.weights.should == { "A" => 1_000_000, "B" => 2 }
-
-    @wp01.weigh("A")
-    @wp01.weights.should == { "A" => 1_000_000, "B" => 1 }
-
-    @wp01.lighten("B")
-    @wp01.weights.should == { "A" => 1_000_000, "B" => 1 }
-
-    @wp01.weigh("B")
-    @wp01.weights.should == { "A" => 1_000_000, "B" => 2 }
-  end
+    end
 
-  after do
-    FileUtils.rm TMP_FILE  if File.exist? TMP_FILE
-    FileUtils.rm NOT_EXIST_FILE if File.exist? NOT_EXIST_FILE
   end
 
 end

data/weightedpicker.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "weightedpicker"
-  s.version = "0.0.2"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ippei94da"]
-  s.date = "2012-07-13"
+  s.date = "2013-04-10"
   s.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  "
   s.email = "ippei94da@gmail.com"
   s.extra_rdoc_files = [
@@ -26,36 +26,45 @@ Gem::Specification.new do |s|
     "Rakefile",
     "VERSION",
     "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"
   ]
   s.homepage = "http://github.com/ippei94da/weightedpicker"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.11"
+  s.rubygems_version = "1.8.23"
   s.summary = "Picking one item from list at the rate of its weight."
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, ["~> 2.9.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.13.0"])
       s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.1.3"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.3.4"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
       s.add_development_dependency(%q<simplecov>, [">= 0"])
     else
-      s.add_dependency(%q<rspec>, ["~> 2.9.0"])
+      s.add_dependency(%q<rspec>, ["~> 2.13.0"])
       s.add_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_dependency(%q<bundler>, ["~> 1.1.3"])
+      s.add_dependency(%q<bundler>, ["~> 1.3.4"])
       s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
       s.add_dependency(%q<simplecov>, [">= 0"])
     end
   else
-    s.add_dependency(%q<rspec>, ["~> 2.9.0"])
+    s.add_dependency(%q<rspec>, ["~> 2.13.0"])
     s.add_dependency(%q<rdoc>, ["~> 3.12"])
-    s.add_dependency(%q<bundler>, ["~> 1.1.3"])
+    s.add_dependency(%q<bundler>, ["~> 1.3.4"])
     s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
     s.add_dependency(%q<simplecov>, [">= 0"])
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: weightedpicker
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,27 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-13 00:00:00.000000000 Z
+date: 2013-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &71663210 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.9.0
+        version: 2.13.0
   type: :development
   prerelease: false
-  version_requirements: *71663210
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &71662930 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,21 +37,31 @@ dependencies:
         version: '3.12'
   type: :development
   prerelease: false
-  version_requirements: *71662930
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &71662620 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.3
+        version: 1.3.4
   type: :development
   prerelease: false
-  version_requirements: *71662620
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.4
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &71662320 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +69,15 @@ dependencies:
         version: 1.8.3
   type: :development
   prerelease: false
-  version_requirements: *71662320
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &71662030 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +85,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *71662030
+  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  "
@@ -85,7 +110,16 @@ files:
 - Rakefile
 - VERSION
 - 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
 homepage: http://github.com/ippei94da/weightedpicker
@@ -103,7 +137,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -490884429
+      hash: -243347693
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -112,7 +146,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.