OSDN Git Service

Refactored Player#set_sente_from_str().
[shogi-server/shogi-server.git] / mk_rate
diff --git a/mk_rate b/mk_rate
index 458e49a..f935acb 100755 (executable)
--- a/mk_rate
+++ b/mk_rate
@@ -5,7 +5,7 @@
 # Homepage:: http://sourceforge.jp/projects/shogi-server/
 #
 #--
-# Copyright (C) 2006-2008 Daigo Moriwaki <daigo at debian dot org>
+# Copyright (C) 2006-2009 Daigo Moriwaki <daigo at debian dot org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -34,6 +34,9 @@
 # DIR::
 #   CSA files are recursively looked up the directories.
 #
+# --base-date::
+#   a base time point for this calicuration (default now). Ex. '2009-10-31'
+#
 # --half-life::
 #   n [days] (default 60)
 #   
 # --fixed-rate::
 #   rate 
 #
+# --skip-draw-games::
+#   skip draw games. [default: draw games are counted in as 0.5 win and 0.5
+#   lost.]
+#
 # --help::
 #   show this message
 #
@@ -89,7 +96,6 @@
 
 require 'yaml'
 require 'time'
-require 'stringio'
 require 'getoptlong'
 require 'gsl'
 require 'rubygems'
@@ -436,11 +442,7 @@ class WinLossMatrix
 
   def self.mk_win_loss_matrix(players)
     obj = mk_matrix(players)
-    while true do
-      obj, ret = obj.filter
-      break if ret
-    end
-    return obj
+    return obj.filter
   end
 
   ##################
@@ -471,52 +473,36 @@ class WinLossMatrix
   end
 
   ##
-  # Removes the delete_index'th player and returns a new object.
+  # Removes players in a rows such as [1,3,5], and then returns a new
+  # object.
   #
-  #  [ 1 0 0   * [ 1 2 3   * [ 1 0   = [ 1 3
-  #    0 0 1 ]     4 5 6       0 0       7 9 ]
-  #                7 8 9 ]     0 1 ]
-  #
-  def delete_row(delete_index)
-    new_matrix = nil
-    if delete_index == 0 && @matrix.size1 == 1 && @matrix.size2 == 1
+  def delete_rows(rows)
+    rows = rows.sort.reverse
+
+    copied_cols = []
+    (0...size).each do |i|
+      next if rows.include?(i)
+      row = @matrix.row(i).clone
+      rows.each do |j|
+        row.delete_at(j)
+      end
+      copied_cols << row
+    end
+    if copied_cols.size == 0
       new_matrix = GSL::Matrix.new
     else
-      a1 = []
-      size.times do |i|
-        next if i == delete_index
-        v = Array.new(size, 0)
-        v[i] = 1
-        a1 << v
-      end
-      m1 = GSL::Matrix[*a1]
-      a1 = nil
-      m2 = m1.transpose
-      new_matrix = m1 * @matrix * m2
+      new_matrix = GSL::Matrix[*copied_cols]
     end
 
     new_keys = @keys.clone
-    new_keys.delete_at(delete_index)
-
-    unless new_matrix
-      raise "The new matrix is null!"
+    rows.each do |j|
+      new_keys.delete_at(j)
     end
 
     return WinLossMatrix.new(new_keys, new_matrix)
   end
 
   ##
-  # Removes players in a rows; [1,3,5]
-  #
-  def delete_rows(rows)
-    obj = self
-    rows.sort.reverse.each do |index|
-      obj = obj.delete_row(index)
-    end
-    obj
-  end
-
-  ##
   # Removes players who do not pass a criteria to be rated, and returns a
   # new object.
   # 
@@ -535,10 +521,10 @@ class WinLossMatrix
     end
 
     # The recursion ends if there is nothing to delete
-    return [self, true] if delete.empty?
+    return self if delete.empty?
 
     new_obj = delete_rows(delete)
-    return [new_obj, false]
+    new_obj.filter
   end
 
   ##
@@ -612,13 +598,21 @@ def half_life(days)
 end
 
 def _add_win_loss(winner, loser, time)
-  how_long_days = (Time.now - time)/(3600*24)
+  how_long_days = ($options["base-date"] - time)/(3600*24)
   $players[winner] ||= Hash.new { GSL::Vector[0,0] }
   $players[loser]  ||= Hash.new { GSL::Vector[0,0] }
   $players[winner][loser] += GSL::Vector[1.0*half_life(how_long_days),0]
   $players[loser][winner] += GSL::Vector[0,1.0*half_life(how_long_days)]
 end
 
+def _add_draw(player1, player2, time)
+  how_long_days = ($options["base-date"] - time)/(3600*24)
+  $players[player1] ||= Hash.new { GSL::Vector[0,0] }
+  $players[player2] ||= Hash.new { GSL::Vector[0,0] }
+  $players[player1][player2] += GSL::Vector[0.5*half_life(how_long_days),0.5*half_life(how_long_days)]
+  $players[player2][player1] += GSL::Vector[0.5*half_life(how_long_days),0.5*half_life(how_long_days)]
+end
+
 def _add_time(player, time)
   $players_time[player] = time if $players_time[player] < time
 end
@@ -629,7 +623,11 @@ def add(black_mark, black_name, white_name, white_mark, time)
   elsif black_mark == LOSS_MARK && white_mark == WIN_MARK
     _add_win_loss(white_name, black_name, time)
   elsif black_mark == DRAW_MARK && white_mark == DRAW_MARK
-    return
+    if $options["skip-draw-games"]
+      return
+    else
+      _add_draw(black_name, white_name, time)
+    end
   else
     raise "Never reached!"
   end
@@ -644,58 +642,26 @@ def identify_id(id)
   id.gsub(/@.*?\+/,"+")
 end
 
-def grep(file)
-  black_name = nil
-  white_name = nil
-  black_mark = nil
-  white_mark = nil
-  black_id   = nil
-  white_id   = nil
-  time       = nil
-
-  lines = StringIO.new File.open(file).read
-
-  lines.each_line do |str|
-    case str
-    when /^N\+(.*)$/
-      black_name = $1.strip 
-    when /^N\-(.*)$/
-      white_name = $1.strip 
-    when /^'summary:(.*)$/
-      state, p1, p2 = $1.split(":").map {|a| a.strip}    
-      return if state == "abnormal"
-      p1_name, p1_mark = p1.split(" ")
-      p2_name, p2_mark = p2.split(" ")
-      if p1_name == black_name
-        black_name, black_mark = p1_name, p1_mark
-        white_name, white_mark = p2_name, p2_mark
-      elsif p2_name == black_name
-        black_name, black_mark = p2_name, p2_mark
-        white_name, white_mark = p1_name, p1_mark
-      else
-        raise "Never reach!: #{black} #{white} #{p3} #{p2}"
-      end
-    when /^'\$END_TIME:(.*)$/
-      time = Time.parse($1.strip)
-    end # case
-  end # each line
-
-  if /^'rating:(.*)$/ =~ lines.string
-    black_id, white_id = $1.split(":").map {|a| a.strip}
-    black_id = identify_id(black_id)
-    white_id = identify_id(white_id)
-    if black_id && white_id && (black_id != white_id) &&
-       black_mark && white_mark
-      add(black_mark, black_id, white_id, white_mark, time)
-    end
+# Parse a game result line
+#
+def parse(line)
+  time, state, black_mark, black_id, white_id, white_mark, file = line.split("\t")
+  unless time && state && black_mark && black_id &&
+         white_id && white_mark && file
+    $stderr.puts "Failed to parse the line : #{line}"
+    return
   end
-end
 
-def usage
-  $stderr.puts <<-EOF
-USAGE: #{$0} dir [...]
-  EOF
-  exit 1
+  return if state == "abnormal"
+  time = Time.parse(time)
+  return if $options["base-date"] < time
+  black_id = identify_id(black_id)
+  white_id = identify_id(white_id)
+
+  if black_id && white_id && (black_id != white_id) &&
+     black_mark && white_mark
+    add(black_mark, black_id, white_id, white_mark, time)
+  end
 end
 
 def validate(yaml)
@@ -716,11 +682,14 @@ def usage(io)
 USAGE: #{$0} [options] DIR..
   DIR                where CSA files are looked up recursively
 OPTOINS:
+  --base-date         a base time point for this calicuration (default now). Ex. '2009-10-31'
   --half-life         n [days] (default 60)
   --half-life-ignore  m [days] (default  7)
                       after m days, half-life effect works
   --fixed-rate-player player whose rate is fixed at the rate
   --fixed-rate        rate 
+  --skip-draw-games   skip draw games. [default: draw games are counted in
+                      as 0.5 win and 0.5 lost]
   --help              show this message
 EOF
 end
@@ -728,11 +697,13 @@ end
 def main
   $options = Hash::new
   parser = GetoptLong.new(
+    ["--base-date",         GetoptLong::REQUIRED_ARGUMENT],
     ["--half-life",         GetoptLong::REQUIRED_ARGUMENT],
     ["--half-life-ignore",  GetoptLong::REQUIRED_ARGUMENT],
     ["--help", "-h",        GetoptLong::NO_ARGUMENT],
     ["--fixed-rate-player", GetoptLong::REQUIRED_ARGUMENT],
-    ["--fixed-rate",        GetoptLong::REQUIRED_ARGUMENT])
+    ["--fixed-rate",        GetoptLong::REQUIRED_ARGUMENT],
+    ["--skip-draw-games",   GetoptLong::NO_ARGUMENT])
   parser.quiet = true
   begin
     parser.each_option do |name, arg|
@@ -753,14 +724,29 @@ def main
     usage($stdout) 
     exit 0
   end
+  if $options["base-date"]
+    $options["base-date"] = Time::parse $options["base-date"]
+  else
+    $options["base-date"] = Time.now
+  end
   $options["half-life"] ||= 60
   $options["half-life"] = $options["half-life"].to_i
   $options["half-life-ignore"] ||= 7
   $options["half-life-ignore"] = $options["half-life-ignore"].to_i
   $options["fixed-rate"] = $options["fixed-rate"].to_i if $options["fixed-rate"]
 
-  while dir = ARGV.shift do
-    Dir.glob( File.join(dir, "**", "*.csa") ) {|f| grep(f)}
+  if ARGV.empty?
+    while line = $stdin.gets do
+      parse line.strip
+    end
+  else
+    while file = ARGV.shift do
+      File.open(file) do |f|
+        f.each_line do |line|
+          parse line.strip
+        end
+      end 
+    end
   end
 
   yaml = {}