schulze-vote 2.0.6 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 54a125030f5f284e82f05d0a65c077e463a37ad0
-  data.tar.gz: cfa32855bdd40cd8ec4c92b1d96d17f81b635d68
+  metadata.gz: 53d7c71ae5e43fcd9a28bf01eaf4e7f16819f5b0
+  data.tar.gz: 989df507edb37c37e043891c28224b643572b0ea
 SHA512:
-  metadata.gz: 84fb23bc8171ba68ea054785d85ac7215a0372327f55b26df9b305957b0172970faa97cfdfe9f24a63f52cf572d733294bb044628f63aec8322c1d2f27f09461
-  data.tar.gz: ed14fffb19e893095dbbd02e337dd4fabe8eb021ce0e7d5d0efa340278bf756afb993f79f4a831878be06cba74b16f4780445b98f4ff449bbfc934aa177f5a57
+  metadata.gz: 1082070bf51ba9aa979670a21240bc0a42efad17ee2eb385284ed2e5386f850dd537d4f837a04cdf766238cd70e691665615f478366d4735e357fa389da89c30
+  data.tar.gz: c2b409116e6066aebc43250aae94081681d70d700e65738dc246beeacca6c313628d2c19570ed040276a7802ec5a9a50c46ce7df0604cda8bf4adae49a26924a

data/README.md

@@ -27,7 +27,6 @@ gem 'schulze-vote', require: 'schulze_vote'
 require 'schulze_vote'
 vs = SchulzeBasic.do vote_list, candidate_count
 vs.ranks
-vs.ranks_abc
 ```
 
 `SchulzeBasic.do` - SchulzeBasic is a short term for `Vote::Condorcet::Schulze::Basic` and `.do` is a method of this class!
@@ -205,6 +204,13 @@ If the number of results is greater then the `limit_results` parameter then a `T
 is raised.
 If you set this parameter to any value other then `false` be careful to catch and manage the exception properly.
 
+## Classification with ties
+
+You have a `classification_with_ties` that you can call.
+This method return a uniq classification in array of arrays format to display results on screen.
+Please note that for cases like this: https://en.wikipedia.org/wiki/User:MarkusSchulze/Schulze_method_examples#Example_4 
+it will return the following: [[B,D], [A,C]]
+
 ## Contributing to schulze-vote
 
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet

data/lib/vote/condorcet/schulze/basic.rb

@@ -21,6 +21,7 @@ module Vote
                   end
           @vote_matrix = input.matrix
           @candidate_count = input.candidates
+          @candidates = (0..@candidate_count - 1).to_a
           @vote_count = input.voters
           self
         end
@@ -30,6 +31,7 @@ module Vote
           result
           calculate_winners
           rank
+          calculate_beat_couples
         end
 
         attr_reader :vote_matrix
@@ -50,7 +52,7 @@ module Vote
         attr_reader :winners_array
 
         # compute all possible solutions
-        # since this can take days, there is an option to limit the numeber of calculated classifications
+        # since this can take days, there is an option to limit the number of calculated classifications
         # the default is 10. if the system is calculating more then 10 possible classifications it will stop
         # raising a TooManyClassifications exception
         # you can set it to false to disable the limit
@@ -58,8 +60,29 @@ module Vote
           @classifications ||= calculate_classifications(limit_results)
         end
 
-        def beat_couples
-          @beat_couples ||= calculate_beat_couples
+        attr_reader :beat_couples
+
+        attr_reader :ties
+
+        # compute the final classification with ties included
+        # the result is an array of arrays. each position can contain one or more elements in tie
+        # e.g. [[0,1], [2,3], [4], [5]]
+        def classification_with_ties
+          calculate_potential_winners
+          result = []
+          result << @potential_winners  # add potential winners on first place
+          result += @ties.clone.sort_by { |tie| -@ranking[tie[0]] } # add all the ties ordered by ranking
+          result.uniq!  # remove duplicates (potential winners are also ties)
+          excludeds = (@candidates - result.flatten)  # all remaining elements (not in a tie and not winners)
+          excludeds.each do |excluded|
+            result.each_with_index do |position, index|
+              # insert before another element if they have a better ranking
+              break result.insert(index, [excluded]) if has_better_ranking?(excluded, position[0])
+              # insert at the end if it's the last possible position
+              break result.insert(-1, [excluded]) if index == result.size - 1
+            end
+          end
+          result
         end
 
         private
@@ -126,17 +149,35 @@ module Vote
           @potential_winners
         end
 
+        # calculates @beat_couples and @ties in roder to display results afterward
         def calculate_beat_couples
-          beat_couples = []
+          return if @calculated_beat_couples
+          @beat_couples = []
+          @ties = []
           ranks.each_with_index do |_val, idx|
             ranks.each_with_index do |_val2, idx2|
               next if idx == idx2
-              if play_matrix[idx, idx2] > play_matrix[idx2, idx]
-                beat_couples << [idx, idx2]
-              end
+              next @beat_couples << [idx, idx2] if play_matrix[idx, idx2] > play_matrix[idx2, idx]
+              next unless in_tie?(idx, idx2)
+              next if @ties.any? { |tie| ([idx, idx2] - tie).empty? }
+              tie = @ties.find { |tie| tie.any? { |el| el == idx } }
+              next tie << idx2 if tie
+              tie = @ties.find { |tie| tie.any? { |el| el == idx2 } }
+              next tie << idx if tie
+              @ties << [idx, idx2]
             end
           end
-          beat_couples
+          @calculated_beat_couples = true
+        end
+
+        def in_tie?(idx, idx2)
+          play_matrix[idx, idx2] == play_matrix[idx2, idx] &&
+            @ranking[idx] == @ranking[idx2] &&
+            @winners_array[idx] == @winners_array[idx2]
+        end
+
+        def has_better_ranking?(a, b)
+          @ranking[a] > @ranking[b]
         end
 
         def rank_element(el)
@@ -180,7 +221,7 @@ module Vote
         end
 
         def check_limits(classifications, limit_results)
-          raise TooManyClassificationsException if limit_results && classifications.size > limit_results
+          fail TooManyClassificationsException if limit_results && classifications.size > limit_results
         end
 
         def add_element(classifications, classif, _potential_winners, beated_list, start_list, element, limit_results)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: schulze-vote
 version: !ruby/object:Gem::Version
-  version: 2.0.6
+  version: 2.1.0
 platform: ruby
 authors:
 - Alessandro Rodi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-12 00:00:00.000000000 Z
+date: 2016-10-17 00:00:00.000000000 Z
 dependencies: []
 description: This gem is a Ruby implementation of the Schulze voting method (with
   help of the Floyd-Warshall algorithm), a type of the Condorcet voting methods.