tournament-system 0.2.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7da812aeb5ed511131c9e45fc831e8f9b0f2e180
-  data.tar.gz: 365cb097c222baefc6a5f73bab75f982218c69cb
+  metadata.gz: 768d7d740fb6a7c2bec21c85c8d9267029874025
+  data.tar.gz: f4ecb036fee09e7ce76acf9fb459285751adf480
 SHA512:
-  metadata.gz: c7b30d85ab5424e794c440a50c85880a4bb164a8c3d347d3f85b166c49ce2588210187fa1400fd87a78ff6f25bd5476b43cc955dbfae329c00d4da5b8146722e
-  data.tar.gz: 0f487a75cd8820df5ac4b6acbd593db7bb0ea6c769cb66c8d36c6a75244d7665432fc079782b21eca08952ce029ec62d16155ff3380aec06e4dfa5e54dd3629d
+  metadata.gz: 2c7045cb22a5097dfbc2e1823750fd5e2a13e445dffa634c5ce5c96bcd922d34e73e8698d6983749e74012c0f172b7e93ebcc5bfdc1ec17b7eb434bece7af8da
+  data.tar.gz: 7a89d1d96e43e02f60c9e123a6f799ddc0f7970d6b011973e97ce2232e27ac2612fd95ca473075cca28882bc81774185b526dd1a8ca4a74213b982f95d08948e

data/.reek

@@ -11,3 +11,6 @@ TooManyStatements:
 # Reek isn't good at detecting these, especially with state and blocks
 DuplicateMethodCall:
   max_calls: 2
+
+NestedIterators:
+  max_allowed_nesting: 2

data/.rubocop.yml

@@ -2,6 +2,9 @@ AllCops:
   DisplayCopNames: true
   TargetRubyVersion: 2.3
 
+Metrics/LineLength:
+  Max: 120
+
 # This is fine, really
 Style/FileName:
   Enabled: false

data/README.md

@@ -14,7 +14,7 @@ It is designed to easily fit into any memory model you might already have.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'tournament-system'
+gem 'tournament-system', '~> 1.0.0'
 ```
 
 And then execute:
@@ -78,10 +78,10 @@ Tournament::SingleElimination.generate driver
 # Generate a round for a round robin tournament
 Tournament::RoundRobin.generate driver
 
-# Generate a round for a swiss system tournament
-# with Dutch pairings (default) with a minimum pair size of 6 (default 4)
+# Generate a round for a swiss system tournament, pushing byes to the bottom
+#  half (bottom half teams will bye before the top half)
 Tournament::Swiss.generate driver, pairer: Tournament::Swiss::Dutch,
-                                   pair_options: { min_pair_size: 6 }
+                                   pair_options: { push_byes_to: :bottom_half }
 
 # Generate a round for a page playoff system, with an optional bronze match
 Tournament::PagePlayoff.generate driver, bronze_match: true

data/lib/tournament/algorithm/group_pairing.rb

@@ -0,0 +1,66 @@
+module Tournament
+  module Algorithm
+    # This module provides group pairing algorithms
+    module GroupPairing
+      extend self
+
+      # Adjacent pairing (aka. King Of The Hill pairing)
+      #
+      # Pair adjacent teams.
+      #
+      # @example
+      #   adjacent([1, 2, 3, 4]) #=> [[1, 2], [3, 4]]
+      #
+      # @param teams [Array<team>]
+      # @return [Array<Array(team, team)>]
+      def adjacent(teams)
+        teams.each_slice(2).to_a
+      end
+
+      # Fold pairing (aka. Slaughter pairing)
+      #
+      # Pair the top team with the bottom team
+      #
+      # @example
+      #   fold([1, 2, 3, 4]) #=> [[1, 4], [2, 3]]
+      #
+      # @param teams [Array<team>]
+      # @return [Array<Array(team, team)>]
+      def fold(teams)
+        top, bottom = teams.each_slice(teams.length / 2).to_a
+
+        bottom.reverse!
+
+        top.zip(bottom).to_a
+      end
+
+      # Slide pairing (aka cross pairing).
+      #
+      # Pair the top half of teams with the bottom half, respectively.
+      #
+      # @example
+      #   pair([1, 2, 3, 4]) #=> [[1, 3], [2, 4]]
+      #
+      # @param teams [Array<team>]
+      # @return [Array<Array(team, team)>]
+      def slide(teams)
+        top, bottom = teams.each_slice(teams.length / 2).to_a
+
+        top.zip(bottom).to_a
+      end
+
+      # Random pairing
+      #
+      # Pair teams randomly.
+      #
+      # @example
+      #   pair([1, 2, 3, 4, 5, 6]) #=> [[1, 4], [2, 6], [3, 5]]
+      #
+      # @param teams [Array<team>]
+      # @return [Array<Array(team, team)>]
+      def random(teams)
+        adjacent(teams.shuffle)
+      end
+    end
+  end
+end

data/lib/tournament/algorithm/matching.rb

@@ -0,0 +1,105 @@
+require 'graph_matching'
+
+module Tournament
+  module Algorithm
+    # Implements graph matching algorithms for tournament systems.
+    module Matching
+      extend self
+
+      # rubocop:disable Metrics/MethodLength
+      # :reek:NestedIterators
+
+      # Iterate all perfect matchings of a specific size. A perfect matchings is a unique grouping of all elements with
+      # a specific group size.
+      #
+      # Note that iterating all perfect matchings can be expensive. The total amount of matchings for size +n+ is given
+      # by +(n - 1)!!+, a double factorial.
+      #
+      # @example
+      #   all_perfect_matchings([1, 2, 3, 4]).includes?([[1, 2], [3, 4]]) #=> true
+      #
+      # @param array [Array<element>]
+      # @overload all_perfect_matchings(array, size)
+      #   @return [Enumerator<Array<element>>] enumerator for all perfect matches
+      # @overload all_perfect_matchings(array, size) { |group| ... }
+      #   @yieldparam group [Array(element, size)] a group of elements
+      #   @return [nil]
+      def all_perfect_matchings(array)
+        return to_enum(:all_perfect_matchings, array) unless block_given?
+
+        if array.empty?
+          yield []
+          return
+        end
+
+        array[1..-1].combination(1) do |group|
+          group.unshift array[0]
+
+          remaining = array.reject { |element| group.include?(element) }
+          all_perfect_matchings(remaining) do |groups|
+            yield [group] + groups
+          end
+        end
+      end
+      # rubbocop:enable Metrics/MethodLength
+
+      # Performs maximum weight perfect matching of a undirected complete graph composed of the given vertices.
+      #
+      # The block is called for every edge in the complete graph.
+      #
+      # Implementation performs in +O(v^3 log v)+.
+      #
+      # @param array [Array<element>]
+      # @yieldparam first [element] The first element of an edge to compute the weight of.
+      # @yieldparam second [element] The second element of an edge to compute the weight of.
+      # @return [Array<Array(element, element)>] A perfect matching with maximum weight
+      def maximum_weight_perfect_matching(array, &block)
+        edges = create_complete_graph(array, &block)
+        graph = GraphMatching::Graph::WeightedGraph[*edges]
+
+        # Get the maximum weighted maximum cardinality matching of the complete graph
+        matching = graph.maximum_weighted_matching(true)
+
+        # Converted matching back to input values (remember, indecies start from 1 in this case)
+        matching.edges.map do |edge|
+          edge.map do |index|
+            array[index - 1]
+          end
+        end
+      end
+
+      # Identical to {#maximum_weight_perfect_matching}, except instead of maximizing weight it minimizes it.
+      #
+      # This is simply achieved by negating the weight and then maximizing that.
+      #
+      # @param array [Array<element>]
+      # @yieldparam first [element] The first element of an edge to compute the weight of.
+      # @yieldparam second [element] The second element of an edge to compute the weight of.
+      # @return [Array<Array(element, element)>] A perfect matching with minimum weight
+      def minimum_weight_perfect_matching(array)
+        maximum_weight_perfect_matching(array) do |first, second|
+          -yield(first, second)
+        end
+      end
+
+      private
+
+      # Construct a complete graph from element indecies (starting from 1)
+      def create_complete_graph(array)
+        edges = []
+
+        array.each.with_index do |first, first_index|
+          next_index = first_index + 1
+
+          array[next_index..array.length].each.with_index do |second, second_index|
+            second_index += next_index
+
+            edges << [next_index, second_index + 1, yield(first, second)]
+          end
+        end
+
+        edges
+      end
+    end
+  end
+end

data/lib/tournament/algorithm/round_robin.rb

@@ -1,5 +1,5 @@
 require 'tournament/algorithm/util'
-require 'tournament/algorithm/pairers/halves'
+require 'tournament/algorithm/group_pairing'
 
 module Tournament
   module Algorithm
@@ -45,7 +45,7 @@ module Tournament
 
       # Rotates teams and pairs them for a round of round robin.
       #
-      # Uses {Pairers::Halves} for pairing after rotating.
+      # Uses {GroupPairing#fold} for pairing after rotating.
       #
       # @param teams [Array<team>] teams playing
       # @param round [Integer] the round number
@@ -53,7 +53,7 @@ module Tournament
       def round_robin_pairing(teams, round)
         rotated = round_robin(teams, round)
 
-        Pairers::Halves.pair(rotated, bottom_reversed: true)
+        GroupPairing.fold(rotated)
       end
     end
   end

data/lib/tournament/algorithm/single_bracket.rb

@@ -66,7 +66,7 @@ module Tournament
       # ones, the first team plays the second in the finals, the 3rd and 4th get
       # nocked out in the semi-finals, etc.
       #
-      # Designed to be used with {Pairers::Adjacent}.
+      # Designed to be used with {GroupPairing#adjacent}.
       #
       # @param teams [Array<Team>]
       # @return [Array<team>]

data/lib/tournament/algorithm/swiss.rb

@@ -1,14 +1,11 @@
 module Tournament
   module Algorithm
-    # This module provides algorithms for dealing with swiss tournament systems.
-    # Specifically it provides algorithms for grouping teams.
-    #
-    # @see Pairers Pairers for possible use with swiss.
+    # This module provides algorithms for dealing with swiss tournament systems. Specifically it provides algorithms for
+    # grouping teams.
     module Swiss
       extend self
 
-      # Calculates the minimum number of rounds needed to properly order teams
-      # using the swiss tournament system.
+      # Calculates the minimum number of rounds needed to properly order teams using the swiss tournament system.
       #
       # @param teams_count [Integer] the number of teams
       # @return [Integer]
@@ -29,44 +26,12 @@ module Tournament
         sorted_keys.map { |key| groups[key] }
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      # :reek:DuplicateMethodCall
-
-      # Merge small groups to the right (if possible) such that all groups
-      # are larger than min_size.
-      # Merging is performed in-place.
-      #
-      # @param groups [Array<Array<team>>] groups of teams
-      # @param min_size [Integer] the minimum size of groups
-      # @return [void]
-      def merge_small_groups(groups, min_size)
-        # Iterate all groups up until the last
-        index = 0
-        while index < groups.length - 1
-          # Merge group to the right until this group is large enough
-          while groups[index].length < min_size && index + 1 < groups.length
-            groups[index] += groups.delete_at(index + 1)
-          end
-
-          index += 1
-        end
-
-        # Merge the last group to the left if its too small
-        if groups[-1].length < min_size && groups.length != 1
-          last = groups.delete_at(-1)
-          groups[-1] += last
-        end
-
-        nil
-      end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-
       # Rollover the last person in each group if its odd.
       # This assumes that the total number of players in all groups is even.
       # Rollover is performed in-place.
       #
       # @param groups [Array<Array<team>>] groups of teams
-      # @return [void]
+      # @return [nil]
       def rollover_groups(groups)
         groups.each_with_index do |group, index|
           # Move last from the current group to the front of the next group

data/lib/tournament/algorithm/util.rb

@@ -54,47 +54,6 @@ module Tournament
         min_elements
       end
       # rubocop:enable Metrics/MethodLength
-
-      # rubocop:disable Metrics/MethodLength
-      # :reek:NestedIterators
-
-      # Iterate all perfect matches of a specific size.
-      # A perfect matching is a unique grouping of all elements with a specific
-      # group size. For example +[[1, 2], [3, 4]]+ is a perfect match of
-      # +[1, 2, 3, 4]+ with group size of +2+.
-      #
-      # This is useful for example when a pairing algorithm needs to iterate all
-      # possible pairings of teams to determine which is the best.
-      #
-      # Warning, this currently only works for +size = 2+.
-      #
-      # @param array [Array<element>]
-      # @param size [Integer] the size of groups
-      # @overload all_perfect_matches(array, size)
-      #   @return [Enumerator<Array<element>>] enumerator for all perfect
-      #                                        matches
-      # @overload all_perfect_matches(array, size) { |group| ... }
-      #   @yieldparam group [Array(element, size)] a group of elements
-      #   @return [void]
-      def all_perfect_matches(array, size)
-        size = 2
-        return to_enum(:all_perfect_matches, array, size) unless block_given?
-
-        if array.empty?
-          yield []
-          return
-        end
-
-        array[1..-1].combination(size - 1) do |group|
-          group.unshift array[0]
-
-          remaining = array.reject { |element| group.include?(element) }
-          all_perfect_matches(remaining, size) do |groups|
-            yield [group] + groups
-          end
-        end
-      end
-      # rubbocop:enable Metrics/MethodLength
     end
   end
 end

data/lib/tournament/driver.rb

@@ -21,29 +21,28 @@ module Tournament
     # rubocop:disable Lint/UnusedMethodArgument
     # :nocov:
 
-    # Get all matches. Required to implement.
+    # Required to implement: Get all matches.
     #
     # @return [Array<match>]
     def matches
       raise 'Not Implemented'
     end
 
-    # Get the teams with their initial seedings. Required to implement.
+    # Required to implement: Get the teams with their initial seedings.
     #
     # @return [Array<team>]
     def seeded_teams
       raise 'Not Implemented'
     end
 
-    # Get the teams ranked by their current position in the tournament.
-    # Required to implement.
+    # Required to implement: Get the teams ranked by their current position in the tournament.
     #
     # @return [Array<team>]
     def ranked_teams
       raise 'Not Implemented'
     end
 
-    # Get the winning team of a match. Required to implement.
+    # Required to implement: Get the winning team of a match.
     #
     # @param match [] a match, eg. one returned by {#matches}
     # @return [team, nil] the winner of the match if applicable
@@ -51,7 +50,7 @@ module Tournament
       raise 'Not Implemented'
     end
 
-    # Get the pair of teams playing for a match. Required to implement.
+    # Required to implement: Get the pair of teams playing for a match.
     #
     # @param match [] a match, eg. one returned by {#matches}
     # @return [Array(team, team)] the pair of teams playing in the match
@@ -59,7 +58,7 @@ module Tournament
       raise 'Not Implemented'
     end
 
-    # Get a specific score for a team. Required to implement.
+    # Required to implement: Get a specific score for a team.
     #
     # @param team [] a team, eg. one returned by {#seeded_teams}
     # @return [Number] the score of the team
@@ -67,8 +66,7 @@ module Tournament
       raise 'Not Implemented'
     end
 
-    # Called when a match is created by a tournament system. Required to
-    # implement.
+    # Required to implement: Called when a match is created by a tournament system.
     #
     # @example rails
     #   def build_match(home_team, away_team)
@@ -78,7 +76,7 @@ module Tournament
     # @param home_team [team] the home team for the match, never +nil+
     # @param away_team [team, nil] the away team for the match, may be +nil+ for
     #     byes.
-    # @return [void]
+    # @return [nil]
     def build_match(home_team, away_team)
       raise 'Not Implemented'
     end
@@ -86,9 +84,8 @@ module Tournament
     # :nocov:
     # rubocop:enable Lint/UnusedMethodArgument
 
-    # Get the losing team of a specific match. By default uses
-    # {#get_match_winner} and {#get_match_teams} to determine which team lost.
-    # Override if you have better access to this information.
+    # Get the losing team of a specific match. By default uses {#get_match_winner} and {#get_match_teams} to determine
+    # which team lost. Override if you have better access to this information.
     #
     # @return [team, nil] the lower of the match, if applicable
     def get_match_loser(match)
@@ -98,16 +95,14 @@ module Tournament
       get_match_teams(match).reject { |team| team == winner }.first
     end
 
-    # Get a hash of unique team pairs and their number of occurences. Used by
-    # tournament systems.
+    # Get a hash of unique team pairs and their number of occurences. Used by tournament systems.
     #
     # @return [Hash{Set(team, team) => Integer}]
     def matches_hash
       @matches_hash ||= build_matches_hash
     end
 
-    # Count the number of times each pair of teams has played already. Used by
-    # tournament systems.
+    # Count the number of times each pair of teams has played already. Used by tournament systems.
     #
     # @param matches [Array<match>]
     # @return [Integer] the number of duplicate matches
@@ -121,7 +116,7 @@ module Tournament
     #
     # @param home_team [team, nil]
     # @param away_team [team, nil]
-    # @return [void]
+    # @return [nil]
     # @raise when both teams are +nil+
     def create_match(home_team, away_team)
       home_team, away_team = away_team, home_team unless home_team
@@ -134,7 +129,7 @@ module Tournament
     # @see #create_match
     #
     # @param matches [Array<Array(team, team)>] a collection of pairs
-    # @return [void]
+    # @return [nil]
     def create_matches(matches)
       matches.each do |home_team, away_team|
         create_match(home_team, away_team)

data/lib/tournament/page_playoff.rb

@@ -1,5 +1,5 @@
 require 'tournament/algorithm/page_playoff'
-require 'tournament/algorithm/pairers/adjacent'
+require 'tournament/algorithm/group_pairing'
 
 module Tournament
   # Implements the page playoff system.
@@ -46,7 +46,7 @@ module Tournament
     private
 
     def semi_finals(driver, teams)
-      driver.create_matches Algorithm::Pairers::Adjacent.pair(teams)
+      driver.create_matches Algorithm::GroupPairing.adjacent(teams)
     end
 
     def preliminary_finals(driver)

data/lib/tournament/round_robin.rb

@@ -10,7 +10,7 @@ module Tournament
     #
     # @param driver [Driver]
     # @option options [Integer] round the round to generate
-    # @return [void]
+    # @return [nil]
     def generate(driver, options = {})
       round = options[:round] || guess_round(driver)
 

data/lib/tournament/single_elimination.rb

@@ -1,5 +1,5 @@
 require 'tournament/algorithm/single_bracket'
-require 'tournament/algorithm/pairers/adjacent'
+require 'tournament/algorithm/group_pairing'
 
 module Tournament
   # Implements the single bracket elimination tournament system.
@@ -9,7 +9,7 @@ module Tournament
     # Generate matches with the given driver
     #
     # @param driver [Driver]
-    # @return [void]
+    # @return [nil]
     def generate(driver, _options = {})
       round = guess_round(driver)
 
@@ -21,7 +21,7 @@ module Tournament
                 get_match_winners driver, last_matches
               end
 
-      driver.create_matches Algorithm::Pairers::Adjacent.pair(teams)
+      driver.create_matches Algorithm::GroupPairing.adjacent(teams)
     end
 
     # The total number of rounds needed for a single elimination tournament with

data/lib/tournament/swiss.rb

@@ -13,7 +13,7 @@ module Tournament
     #                                 {Dutch}
     # @option options [Hash] pair_options options for the chosen pairing system,
     #                                     see {Dutch} for more details
-    # @return [void]
+    # @return [nil]
     def generate(driver, options = {})
       pairer = options[:pairer] || Dutch
       pairer_options = options[:pair_options] || {}
@@ -23,7 +23,7 @@ module Tournament
       driver.create_matches(pairings)
     end
 
-    # The minimum number of rounds to determine a winner.
+    # The minimum number of rounds to determine a number of winners.
     #
     # @param driver [Driver]
     # @return [Integer]

data/lib/tournament/swiss/dutch.rb

@@ -1,7 +1,8 @@
+require 'ostruct'
+
 require 'tournament/algorithm/swiss'
-require 'tournament/algorithm/pairers/multi'
-require 'tournament/algorithm/pairers/halves'
-require 'tournament/algorithm/pairers/best_min_duplicates'
+require 'tournament/algorithm/matching'
+require 'tournament/algorithm/group_pairing'
 
 module Tournament
   module Swiss
@@ -11,55 +12,104 @@ module Tournament
 
       # Pair teams using dutch pairing for a swiss system tournament.
       #
+      # Teams are initially grouped by their score and then slide paired ({Tournament::Algorithm::GroupPairing.slide}).
+      # If that fails to produce unique matches it will match teams by the minimum score difference, aniling duplicate
+      # matches (default) and optionally pushing byes to a certain side.
+      #
       # @param driver [Driver]
-      # @option options [Integer] min_pair_size see
-      #     {Algorithm::Swiss#merge_small_groups for more details}
+      # @option options [Boolean] allow_duplicates removes the penalty of duplicate matches from the pairing algorithm
+      # @option options [:none, :top_half, :bottom_half] push_byes_to adds a penalty to the pairing algorithm for when a
+      #     bye match is not with a team in the desired position.
       # @return [Array<Array(team, team)>] the generated pairs of teams
       def pair(driver, options = {})
+        state = build_state(driver, options)
+
+        dutch_pairings = generate_dutch_pairings(state)
+
+        duplicates = driver.count_duplicate_matches(dutch_pairings)
+
+        if duplicates.zero?
+          dutch_pairings
+        else
+          generate_best_pairings(state)
+        end
+      end
+
+      private
+
+      def build_state(driver, options)
+        OpenStruct.new(
+          driver:           driver,
+          teams:            get_teams(driver),
+          scores:           driver.scores_hash,
+          allow_duplicates: options.fetch(:allow_duplicates, false),
+          push_byes_to:     options.fetch(:push_byes_to, :none)
+        )
+      end
+
+      def get_teams(driver)
         teams = driver.ranked_teams.dup
 
-        # Special padding such that the bottom team gets a BYE
+        # Special padding such that the bottom team gets a BYE with dutch
         teams.insert(teams.length / 2, nil) if teams.length.odd?
 
-        scores = driver.scores_hash
-        groups = Algorithm::Swiss.group_teams_by_score(teams, scores)
+        teams
+      end
 
-        min_pair_size = options[:min_pair_size] || 4
-        Algorithm::Swiss.merge_small_groups(groups, min_pair_size)
+      def generate_dutch_pairings(state)
+        groups = Algorithm::Swiss.group_teams_by_score(state.teams, state.scores)
 
+        # Make sure all groups are at least of size 2
         Algorithm::Swiss.rollover_groups(groups)
 
-        pair_groups driver, groups
+        groups.map do |group|
+          Algorithm::GroupPairing.slide(group)
+        end.reduce(:+)
       end
 
-      private
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
-      def pairer_funcs(driver, group)
-        scores = driver.scores_hash
-        matches = driver.matches_hash
+      def generate_best_pairings(state)
+        teams = state.teams
 
-        [
-          -> () { Algorithm::Pairers::Halves.pair(group) },
-          lambda do
-            Algorithm::Pairers::BestMinDuplicates.pair(group, scores, matches)
-          end,
-        ]
-      end
+        state.matches = state.driver.matches_hash
+
+        state.score_range = state.scores.keys.max - state.scores.keys.min
+        state.average_score_difference = state.score_range / teams.length.to_f
+
+        state.team_index_map = teams.map.with_index.to_h
 
-      def pair_groups(driver, groups)
-        groups.map { |group| pair_group(driver, group) }.reduce(:+)
+        Algorithm::Matching.minimum_weight_perfect_matching(teams) do |home_team, away_team|
+          cost_function(state, home_team, away_team)
+        end
       end
 
-      def pair_group(driver, group)
-        Algorithm::Pairers::Multi.pair(pairer_funcs(driver, group)) do |matches|
-          duplicates = driver.count_duplicate_matches(matches)
+      # This function will be called a lot, so it needs to be pretty fast (run in +O(1)+)
+      def cost_function(state, home_team, away_team)
+        match_set = Set[home_team, away_team]
+        cost = 0
+
+        # Reduce score distance between teams
+        cost += (state.scores[home_team] || 0 - state.scores[away_team] || 0).abs
+
+        # The cost of a duplicate is the score range + 1
+        cost += (state.score_range + 1) * state.matches[match_set] unless state.allow_duplicates
 
-          # Early return when there are no duplicates, prefer earlier pairers
-          return matches if duplicates.zero?
+        # Add cost for bye matches not on the preferred side
+        push_byes_to = state.push_byes_to
+        if match_set.include?(nil) && push_byes_to != :none
+          index = state.team_index_map[home_team || away_team]
 
-          -duplicates
+          if (push_byes_to == :bottom_half && index > state.teams.length / 2) ||
+             (push_byes_to == :top_half && index < state.teams.length / 2)
+            cost += state.score_range
+          end
         end
+
+        cost
       end
+
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     end
   end
 end

data/lib/tournament/version.rb

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

data/tournament-system.gemspec

@@ -23,5 +23,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_runtime_dependency 'graph_matching', '~> 0.1.1'
   spec.add_development_dependency 'bundler', '~> 1.14'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: tournament-system
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Benjamin Schaaf
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-01 00:00:00.000000000 Z
+date: 2017-09-29 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: graph_matching
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -43,12 +57,9 @@ files:
 - lib/tournament-system.rb
 - lib/tournament.rb
 - lib/tournament/algorithm.rb
+- lib/tournament/algorithm/group_pairing.rb
+- lib/tournament/algorithm/matching.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

data/lib/tournament/algorithm/pairers.rb

@@ -1,7 +0,0 @@
-module Tournament
-  module Algorithm
-    # This module provides multiple pairing algorithms
-    module Pairers
-    end
-  end
-end

data/lib/tournament/algorithm/pairers/adjacent.rb

@@ -1,21 +0,0 @@
-module Tournament
-  module Algorithm
-    module Pairers
-      # Basic pairer for adjacent teams.
-      module Adjacent
-        extend self
-
-        # Pair adjacent teams.
-        #
-        # @example
-        #   pair([1, 2, 3, 4]) #=> [[1, 2], [3, 4]]
-        #
-        # @param teams [Array<team>]
-        # @return [Array<Array(team, team)>]
-        def pair(teams)
-          teams.each_slice(2).to_a
-        end
-      end
-    end
-  end
-end

data/lib/tournament/algorithm/pairers/best_min_duplicates.rb

@@ -1,55 +0,0 @@
-require 'tournament/algorithm/util'
-
-module Tournament
-  module Algorithm
-    module Pairers
-      # Complex pairing system that tries to maximise uniqueness and
-      # total score difference.
-      module BestMinDuplicates
-        extend self
-
-        # Pair by minimising the number of duplicate matches,
-        # then minimising the score difference.
-        #
-        # @see Util.all_perfect_matches
-        #
-        # @param teams [Array<team>] the teams to pair
-        # @param scores [Hash{team => Numer}] a mapping from teams to scores
-        # @param matches_counts [Hash{Set(team, team) => Integer}]
-        #   A mapping from unique matches to their number of previous
-        #   occurrences.
-        def pair(teams, scores, matches_counts)
-          # enumerate all unique pairings using round robin
-          perfect_matches = Util.all_perfect_matches(teams, 2)
-
-          # Find all possible pairings with minimum duplicates
-          min_pairings = perfect_matches.group_by do |matches|
-            count_duplicate_matches(matches_counts, matches)
-          end.min_by(&:first).last
-
-          # Pick the pairings with least total score difference
-          min_pairings = Util.all_min_by(min_pairings) do |matches|
-            score_difference(scores, matches)
-          end
-
-          # Pick the last one as its usually the most diverse
-          min_pairings.last
-        end
-
-        private
-
-        def count_duplicate_matches(matches_counts, matches)
-          matches.map { |match| matches_counts[Set.new match] || 0 }.reduce(:+)
-        end
-
-        def score_difference(scores, matches)
-          # Default to a score of 0
-          score_h = Hash.new { |hash, key| hash[key] = scores[key] || 0 }
-
-          matches.map { |match| (score_h[match[0]] - score_h[match[1]]).abs }
-                 .reduce(:+)
-        end
-      end
-    end
-  end
-end

data/lib/tournament/algorithm/pairers/halves.rb

@@ -1,32 +0,0 @@
-module Tournament
-  module Algorithm
-    module Pairers
-      # Basic pairer that matches the top half with the bottom half
-      module Halves
-        extend self
-
-        # Pair the top half of teams with the bottom half.
-        #
-        # @example
-        #   pair([1, 2, 3, 4]) #=> [[1, 3], [2, 4]]
-        #
-        # @example
-        #   pair([1, 2, 3, 4], bottom_reversed: true) #=> [[1, 4], [2, 3]]
-        #
-        # @param teams [Array<team>]
-        # @param bottom_reversed [Boolean] whether to reverse the bottom half
-        #                                  before pairing both halves.
-        # @return [Array<Array(team, team)>]
-        # :reek:BooleanParameter
-        # :reek:ControlParameter
-        def pair(teams, bottom_reversed: false)
-          top, bottom = teams.each_slice(teams.length / 2).to_a
-
-          bottom.reverse! if bottom_reversed
-
-          top.zip(bottom).to_a
-        end
-      end
-    end
-  end
-end

data/lib/tournament/algorithm/pairers/multi.rb

@@ -1,33 +0,0 @@
-module Tournament
-  module Algorithm
-    module Pairers
-      # Modular pairer for combining multiple pairing algorithms.
-      module Multi
-        extend self
-
-        # Generic way of combining multiple pairing algorithms.
-        #
-        # Given a set of pair functions, generate pairs using each of them and
-        # use the block to determine a value for this pairing. The function will
-        # return the pairing generated that produced the highest score.
-        #
-        # @param pair_funcs [Array<lambda>] the array of pairers
-        # @yieldparam pairings [] a set of pairings generated by +pair_funcs+
-        # @yieldreturn [Number] a score for the set of pairings
-        # @return the set of pairings with the highest score
-        def pair(pair_funcs)
-          # Score all pairings
-          pairings = pair_funcs.map do |pair_func|
-            matches = pair_func.call
-            score = yield matches
-
-            [matches, score]
-          end
-
-          # Use the pairings with the highest score
-          pairings.max_by { |pair| pair[1] }.first
-        end
-      end
-    end
-  end
-end