tournament-system 0.1.4 → 0.1.5

data/lib/tournament/swiss/dutch.rb

@@ -1,61 +1,63 @@
+require 'tournament/algorithm/swiss'
+require 'tournament/algorithm/pairers/multi'
+require 'tournament/algorithm/pairers/halves'
+require 'tournament/algorithm/pairers/best_min_duplicates'
+
 module Tournament
   module Swiss
     # A simplified Dutch pairing system implementation.
     module Dutch
       extend self
-      extend Common
 
-      def pair(driver, teams, options = {})
-        return dutch_pairing(teams) if driver.matches.empty?
+      # Pair teams using dutch pairing for a swiss system tournament.
+      #
+      # @param driver [Driver]
+      # @option options [Integer] min_pair_size see
+      #     {Algorithm::Swiss#merge_small_groups for more details}
+      # @return [Array<Array(team, team)>] the generated pairs of teams
+      def pair(driver, options = {})
+        teams = driver.ranked_teams
+
+        # Special padding such that the bottom team gets a BYE
+        teams.insert(teams.length / 2, nil) if teams.length.odd?
 
-        groups, group_keys = group_teams_by_score(driver, teams)
+        scores = driver.scores_hash
+        groups = Algorithm::Swiss.group_teams_by_score(teams, scores)
 
         min_pair_size = options[:min_pair_size] || 4
-        group_keys = merge_small_groups(groups, group_keys, min_pair_size)
+        Algorithm::Swiss.merge_small_groups(groups, min_pair_size)
 
-        pair_groups driver, groups, group_keys
+        Algorithm::Swiss.rollover_groups(groups)
+
+        pair_groups driver, groups
       end
 
       private
 
-      # Match the top half with the bottom half
-      def dutch_pairing(teams)
-        half = teams.length / 2
-        top = teams[0...half]
-        bottom = teams[half..-1]
-        top << nil if top.length < bottom.length
+      def pairer_funcs(driver, group)
+        scores = driver.scores_hash
+        matches = driver.matches_hash
 
-        top.zip(bottom).to_a
+        [
+          -> () { Algorithm::Pairers::Halves.pair(group) },
+          lambda do
+            Algorithm::Pairers::BestMinDuplicates.pair(group, scores, matches)
+          end,
+        ]
       end
 
-      def pair_groups(driver, groups, group_keys)
-        existing_matches = matches_set(driver)
-
-        matches = []
-        each_group_with_rollover(groups, group_keys) do |group|
-          matches += pair_group(group, existing_matches)
-        end
-
-        matches
+      def pair_groups(driver, groups)
+        groups.map { |group| pair_group(driver, group) }.reduce(:+)
       end
 
-      def pair_group(group, existing_matches)
-        pairs = dutch_pairing(group)
+      def pair_group(driver, group)
+        Algorithm::Pairers::Multi.pair(pairer_funcs(driver, group)) do |matches|
+          duplicates = driver.count_duplicate_matches(matches)
 
-        if any_match_exists?(pairs, existing_matches)
-          first_permutation_pairing(group, existing_matches) do |perm_pairs|
-            dutch_pairing(perm_pairs)
-          end
-        else
-          pairs
-        end
-      end
+          # Early return when there are no duplicates, prefer earlier pairers
+          return matches if duplicates.zero?
 
-      def fix_matches(teams, pairs, existing_matches)
-        if any_match_exists?(pairs, existing_matches)
-          first_permutation_pairing(teams, existing_matches)
-        else
-          pairs
+          -duplicates
         end
       end
     end

data/lib/tournament/swiss.rb

@@ -1,4 +1,4 @@
-require 'tournament/swiss/common'
+require 'tournament/algorithm/swiss'
 require 'tournament/swiss/dutch'
 
 module Tournament
@@ -6,34 +6,29 @@ module Tournament
   module Swiss
     extend self
 
+    # Generate matches with the given driver.
+    #
+    # @param driver [Driver]
+    # @option options [Pairer] pairer the pairing system to use, defaults to
+    #                                 {Dutch}
+    # @option options [Hash] pair_options options for the chosen pairing system,
+    #                                     see {Dutch} for more details
+    # @return [void]
     def generate(driver, options = {})
       pairer = options[:pairer] || Dutch
       pairer_options = options[:pair_options] || {}
 
-      teams = seed_teams driver.ranked_teams, options
+      pairings = pairer.pair(driver, pairer_options)
 
-      pairings = pairer.pair driver, teams, pairer_options
-
-      create_matches driver, pairings
+      driver.create_matches(pairings)
     end
 
+    # The minimum number of rounds to determine a winner.
+    #
+    # @param driver [Driver]
+    # @return [Integer]
     def minimum_rounds(driver)
-      team_count = driver.seeded_teams.length
-
-      Math.log2(team_count).ceil
-    end
-
-    private
-
-    def seed_teams(teams, options)
-      seeder = options[:seeder] || Seeder::None
-      seeder.seed teams
-    end
-
-    def create_matches(driver, pairings)
-      pairings.each do |pair|
-        driver.create_match(pair[0], pair[1])
-      end
+      Algorithm::Swiss.minimum_rounds(driver.seeded_teams.length)
     end
   end
 end

data/lib/tournament/version.rb

@@ -1,3 +1,4 @@
 module Tournament
-  VERSION = '0.1.4'.freeze
+  # The current version of this gem.
+  VERSION = '0.1.5'.freeze
 end

data/lib/tournament-system.rb

@@ -1,8 +1,6 @@
 require 'tournament/version'
 require 'tournament/driver'
 
-require 'tournament/seeder'
-
 require 'tournament/swiss'
 require 'tournament/round_robin'
 require 'tournament/page_playoff'

data/lib/tournament.rb

@@ -0,0 +1,6 @@
+# This library is split into two parts, there's the actual algorithms that
+# implement various tournament systems ({Algorithm}) and a data abstraction
+# layer for generating matches using various tournament systems in a
+# data-independent way ({Driver}).
+module Tournament
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tournament-system
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Benjamin Schaaf
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-02 00:00:00.000000000 Z
+date: 2017-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -41,16 +41,23 @@ files:
 - README.md
 - Rakefile
 - lib/tournament-system.rb
+- lib/tournament.rb
+- lib/tournament/algorithm.rb
+- lib/tournament/algorithm/page_playoff.rb
+- lib/tournament/algorithm/pairers.rb
+- lib/tournament/algorithm/pairers/adjacent.rb
+- lib/tournament/algorithm/pairers/best_min_duplicates.rb
+- lib/tournament/algorithm/pairers/halves.rb
+- lib/tournament/algorithm/pairers/multi.rb
+- lib/tournament/algorithm/round_robin.rb
+- lib/tournament/algorithm/single_bracket.rb
+- lib/tournament/algorithm/swiss.rb
+- lib/tournament/algorithm/util.rb
 - lib/tournament/driver.rb
 - lib/tournament/page_playoff.rb
 - lib/tournament/round_robin.rb
-- lib/tournament/seeder.rb
-- lib/tournament/seeder/none.rb
-- lib/tournament/seeder/random.rb
-- lib/tournament/seeder/single_bracket.rb
 - lib/tournament/single_elimination.rb
 - lib/tournament/swiss.rb
-- lib/tournament/swiss/common.rb
 - lib/tournament/swiss/dutch.rb
 - lib/tournament/version.rb
 - tournament-system.gemspec

data/lib/tournament/seeder/none.rb

@@ -1,12 +0,0 @@
-module Tournament
-  module Seeder
-    # Implements a fall-through tournament seeder. Does no seeding whatsoever.
-    module None
-      extend self
-
-      def seed(teams)
-        teams
-      end
-    end
-  end
-end

data/lib/tournament/seeder/random.rb

@@ -1,14 +0,0 @@
-module Tournament
-  module Seeder
-    # A random seeder.
-    class Random
-      def initialize(random = nil)
-        @random = random
-      end
-
-      def seed(teams)
-        teams.shuffle(random: @random)
-      end
-    end
-  end
-end

data/lib/tournament/seeder/single_bracket.rb

@@ -1,39 +0,0 @@
-module Tournament
-  module Seeder
-    # A seeder for a single-bracket tournament system.
-    # Seeds teams such that the highest expected placing teams should get
-    # furthest in the bracket.
-    module SingleBracket
-      extend self
-
-      def seed(teams)
-        unless (Math.log2(teams.length) % 1).zero?
-          raise ArgumentError, 'Need power-of-2 teams'
-        end
-
-        teams = teams.map.with_index { |team, index| SeedTeam.new(team, index) }
-        seed_bracket(teams).map(&:team)
-      end
-
-      private
-
-      # Structure for wrapping a team with it's seed index
-      SeedTeam = Struct.new(:team, :index)
-
-      # Recursively seed the top half of the teams
-      # and match teams reversed by index to the bottom half
-      def seed_bracket(teams)
-        return teams if teams.length <= 2
-
-        top_half, bottom_half = teams.each_slice(teams.length / 2).to_a
-        top_half = seed top_half
-
-        top_half.map do |team|
-          match = bottom_half[-team.index - 1]
-
-          [team, match]
-        end.flatten
-      end
-    end
-  end
-end

data/lib/tournament/seeder.rb

@@ -1,10 +0,0 @@
-require 'tournament/seeder/none'
-require 'tournament/seeder/random'
-require 'tournament/seeder/single_bracket'
-
-module Tournament
-  # Module containing tournament seeders.
-  # Seeders are used by systems to define initial conditions.
-  module Seeder
-  end
-end

data/lib/tournament/swiss/common.rb

@@ -1,118 +0,0 @@
-module Tournament
-  module Swiss
-    # Common functions for swiss pairing systems..\
-    module Common
-      extend self
-
-      # Iterate over each group, letting a team rollover into the next group
-      # if a group has an odd number of teams
-      def each_group_with_rollover(groups, group_keys)
-        group_keys.each_with_index do |key, index|
-          group = groups[key]
-          # Drop teams to next group get an even number
-          next_key = group_keys[index + 1]
-          groups[next_key] << group.pop if group.length.odd? && next_key
-
-          yield group
-        end
-      end
-
-      # Groups teams by the score given by the driver
-      def group_teams_by_score(driver, teams)
-        groups = teams.group_by { |team| driver.get_team_score team }
-        group_keys = groups.keys.sort.reverse.to_a
-
-        [groups, group_keys]
-      end
-
-      # Merges small groups to the right (if possible) such that all groups
-      # are larger than min_size.
-      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      # :reek:TooManyStatements
-      def merge_small_groups(groups, group_keys, min_size)
-        new_keys = []
-
-        group_keys.each_with_index do |key, index|
-          group = groups[key]
-
-          # Merge small groups into an adjacent group
-          if group.length < min_size
-            groups.delete(key)
-
-            # When there is an adjacent lesser group, merge into that one
-            new_key = group_keys[index + 1]
-            if new_key
-              groups[new_key] = group + groups[new_key]
-            # If there isn't, merge into the adjacent greater group
-            else
-              new_key = new_keys[-1]
-
-              if new_key
-                groups[new_key] += group
-              else
-                # If there are no new keys just use the current key
-                new_keys << key
-                groups[key] = group
-              end
-            end
-          # Leave larger groups the way they are
-          else
-            new_keys << key
-            groups[key] = group
-          end
-        end
-
-        new_keys
-      end
-      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
-
-      # Get a set of already played matches. Matches are also sets
-      def matches_set(driver)
-        existing_matches = Hash.new(0)
-        driver.matches.each do |match|
-          match_teams = Set.new driver.get_match_teams match
-          existing_matches[match_teams] += 1
-        end
-        existing_matches
-      end
-
-      # Check whether any match has already been played
-      def any_match_exists?(matches, existing_matches)
-        matches.any? { |match| existing_matches.include?(Set.new(match)) }
-      end
-
-      # Count the number of matches already played
-      def count_existing_matches(matches, existing_matches)
-        matches.map { |match| existing_matches[Set.new(match)] }.reduce(:+)
-      end
-
-      # Finds the first permutation of teams that has a unique pairing.
-      # If none are found, the pairing that has the least duplicate matches
-      # is returned.
-      # rubocop:disable Metrics/MethodLength
-      def first_permutation_pairing(teams, existing_matches)
-        min_dups = Float::INFINITY
-        best_matches = nil
-
-        # Find the first permutation that has no duplicate matches
-        # Or the permutation with the least duplicate matches
-        teams.permutation.each do |variation|
-          matches = (yield variation).to_a
-          dup_count = count_existing_matches(matches, existing_matches)
-
-          # Quick exit when there are no duplicates
-          return matches if dup_count.zero?
-
-          # Update best stats as we go along
-          if dup_count < min_dups
-            min_dups = dup_count
-            best_matches = matches
-          end
-        end
-
-        best_matches
-      end
-      # rubocop:enable Metrics/MethodLength
-    end
-  end
-end