schulze-vote 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53d7c71ae5e43fcd9a28bf01eaf4e7f16819f5b0
-  data.tar.gz: 989df507edb37c37e043891c28224b643572b0ea
+  metadata.gz: 9866e914ebb502be11324a542dfb49de786a7408
+  data.tar.gz: 6ade5e377c2b4e1f01444fd110e535e54df71ac4
 SHA512:
-  metadata.gz: 1082070bf51ba9aa979670a21240bc0a42efad17ee2eb385284ed2e5386f850dd537d4f837a04cdf766238cd70e691665615f478366d4735e357fa389da89c30
-  data.tar.gz: c2b409116e6066aebc43250aae94081681d70d700e65738dc246beeacca6c313628d2c19570ed040276a7802ec5a9a50c46ce7df0604cda8bf4adae49a26924a
+  metadata.gz: 03f614f995678224821bc5d81fa8e5d86945aa0086f767ad96b35d6d577d2d9742177b2bad6fa23ad4e7fa0560e3f17638cf1113d1738e463d40f912d76a2a5a
+  data.tar.gz: 5088baad29d4959dee3df8d4aa232be97090dda1111648a9c388f65dc87e07f4ce6aac55b757e674bbd0f745866424d3eedeb7f69fa43a095ecd2764f89631d5

data/README.md

@@ -3,6 +3,15 @@
 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.
 
+## Master
+
+[![Build Status](https://travis-ci.org/coorasse/schulze-vote.svg?branch=master)](https://travis-ci.org/coorasse/schulze-vote)
+
+## Develop
+
+[![Build Status](https://travis-ci.org/coorasse/schulze-vote.svg?branch=develop)](https://travis-ci.org/coorasse/schulze-vote)
+[![Code Climate](https://codeclimate.com/github/coorasse/schulze-vote/badges/gpa.svg)](https://codeclimate.com/github/coorasse/schulze-vote)
+[![Test Coverage](https://codeclimate.com/github/coorasse/schulze-vote/badges/coverage.svg)](https://codeclimate.com/github/coorasse/schulze-vote/coverage)
 
 Wikipedia:
 

data/lib/schulze_vote.rb

@@ -6,3 +6,4 @@ autoload :Vote, 'vote'
 
 SchulzeInput = Vote::Condorcet::Schulze::Input
 SchulzeBasic = Vote::Condorcet::Schulze::Basic
+SchulzeClassifications = Vote::Condorcet::Schulze::Classifications

data/lib/vote/condorcet/schulze.rb

@@ -3,6 +3,7 @@ module Vote
     module Schulze
       autoload :Input, 'vote/condorcet/schulze/input'
       autoload :Basic, 'vote/condorcet/schulze/basic'
+      autoload :Classifications, 'vote/condorcet/schulze/classifications'
     end
   end
 end

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

@@ -2,6 +2,14 @@ module Vote
   module Condorcet
     module Schulze
       class Basic
+        attr_reader :candidates, :vote_matrix, :play_matrix, :result_matrix, :ranking, :vote_count
+        attr_reader :winners_array, :potential_winners, :beat_couples, :ties
+
+        def initialize
+          @beat_couples = []
+          @ties = []
+        end
+
         # All-in-One class method to get a calculated SchulzeBasic object
         def self.do(vote_matrix, candidate_count = nil)
           instance = new
@@ -14,10 +22,7 @@ module Vote
           input = if vote_matrix.is_a?(Vote::Condorcet::Schulze::Input)
                     vote_matrix
                   else
-                    Vote::Condorcet::Schulze::Input.new(
-                      vote_matrix,
-                      candidate_count
-                    )
+                    Vote::Condorcet::Schulze::Input.new(vote_matrix, candidate_count)
                   end
           @vote_matrix = input.matrix
           @candidate_count = input.candidates
@@ -32,64 +37,22 @@ module Vote
           calculate_winners
           rank
           calculate_beat_couples
+          calculate_potential_winners
         end
 
-        attr_reader :vote_matrix
-
-        attr_reader :play_matrix
-
-        attr_reader :result_matrix
-
-        def ranks
-          @ranking
-        end
-
-        def voters
-          @vote_count
-        end
-
-        # return all possible solutions to the votation
-        attr_reader :winners_array
+        private
 
-        # compute all possible solutions
-        # 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
-        def classifications(limit_results = false)
-          @classifications ||= calculate_classifications(limit_results)
+        def play
+          @play_matrix = build_play_matrix
+          find_matches_with_wins
+          find_strongest_paths
         end
 
-        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
+        def build_play_matrix
+          ::Matrix.scalar(@candidate_count, 0).extend(Vote::Matrix)
         end
 
-        private
-
-        def play
-          @play_matrix = ::Matrix.scalar(@candidate_count, 0).extend(Vote::Matrix)
-          # step 1: find matches with wins
+        def find_matches_with_wins
           @candidate_count.times do |i|
             @candidate_count.times do |j|
               next if i == j
@@ -100,17 +63,15 @@ module Vote
               end
             end
           end
+        end
 
-          # step 2: find strongest paths
+        def find_strongest_paths
           @candidate_count.times do |i|
             @candidate_count.times do |j|
               next if i == j
               @candidate_count.times do |k|
                 next if (i == k) || (j == k)
-                @play_matrix[j, k] = [
-                  @play_matrix[j, k],
-                  [@play_matrix[j, i], @play_matrix[i, k]].min
-                ].max
+                @play_matrix[j, k] = [@play_matrix[j, k], [@play_matrix[j, i], @play_matrix[i, k]].min].max
               end
             end
           end
@@ -136,112 +97,48 @@ module Vote
         end
 
         def rank
-          @ranking = @result_matrix.
-            row_vectors.map { |e| e.inject(0) { |s, v| s += v } }
+          @ranking = @result_matrix.row_vectors.map { |rm| rm.inject(0) { |a, e| a + e } }
         end
 
         # you should call calculate_winners first
         def calculate_potential_winners
-          @potential_winners = []
-          winners_array.each_with_index do |val, idx|
-            @potential_winners << idx if val > 0
-          end
-          @potential_winners
+          @potential_winners ||= winners_array.map.with_index { |val, idx| idx if val > 0 }.compact
         end
 
         # calculates @beat_couples and @ties in roder to display results afterward
         def calculate_beat_couples
           return if @calculated_beat_couples
-          @beat_couples = []
-          @ties = []
-          ranks.each_with_index do |_val, idx|
-            ranks.each_with_index do |_val2, idx2|
+
+          ranking.each_with_index do |_val, idx|
+            ranking.each_with_index do |_val2, idx2|
               next if idx == idx2
               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]
+              calculate_ties(idx, idx2)
             end
           end
           @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)
-          rank = 0
-          rank -= 100 if @potential_winners.include?(el)
-          beat_couples.each do |b|
-            rank -= 1 if b[0] == el
-          end
-          rank
-        end
-
-        def calculate_classifications(limit_results)
-          calculate_potential_winners
-
-          start_list = (0..ranks.length - 1).to_a
-          start_list.sort! { |e1, e2| rank_element(e1) <=> rank_element(e2) }
-
-          classifications = []
-          compute_classifications(classifications, [], @potential_winners, beat_couples, start_list, limit_results)
-          classifications
-        end
-
-        def compute_classifications(classifications, classif = [], potential_winners,
-                                    beated_list, start_list, limit_results)
-          if beated_list.empty?
-            start_list.permutation.each do |array|
-              classifications << classif + array
-              check_limits(classifications, limit_results)
-            end
-          else
-            if classif.empty? && potential_winners.any?
-              potential_winners.each do |element|
-                add_element(classifications, classif, nil, beated_list, start_list, element, limit_results)
-              end
-            else
-              start_list.each do |element|
-                add_element(classifications, classif, nil, beated_list, start_list, element, limit_results)
-              end
-            end
-          end
+        def calculate_ties(idx, idx2)
+          return unless in_tie?(idx, idx2)
+          return if @ties.any? { |tie| ([idx, idx2] - tie).empty? }
+          found_tie = tie_by_idx(idx)
+          return found_tie << idx2 if found_tie
+          found_tie = tie_by_idx(idx2)
+          return found_tie << idx if found_tie
+          @ties << [idx, idx2]
         end
 
-        def check_limits(classifications, limit_results)
-          fail TooManyClassificationsException if limit_results && classifications.size > limit_results
+        def tie_by_idx(idx)
+          @ties.find { |tie| tie.any? { |el| el == idx } }
         end
 
-        def add_element(classifications, classif, _potential_winners, beated_list, start_list, element, limit_results)
-          return if beated_list.any? { |c| c[1] == element }
-          classification = classif.clone
-          classification << element
-          next_beated_list = beated_list.clone.delete_if { |c| c[0] == element }
-          next_start_list = start_list.clone
-          next_start_list.delete(element)
-          if next_start_list.empty?
-            classifications << classification
-            check_limits(classifications, limit_results)
-          else
-            compute_classifications(classifications, classification, nil, next_beated_list, next_start_list, limit_results)
-          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
       end
     end
   end
 end
-
-class TooManyClassificationsException < StandardError
-end

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

@@ -0,0 +1,109 @@
+module Vote
+  module Condorcet
+    module Schulze
+      class Classifications
+        def initialize(schulze_basic)
+          @schulze_basic = schulze_basic
+        end
+
+        # compute all possible solutions
+        # 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
+        def classifications(limit_results = false)
+          @classifications = []
+          @limit_results = limit_results
+          calculate_classifications
+          @classifications
+        end
+
+        # 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
+          result = []
+          result << @schulze_basic.potential_winners # add potential winners on first place
+          result += @schulze_basic.ties.clone.sort_by { |tie| -@schulze_basic.ranking[tie[0]] } # add ties by ranking
+          result.uniq! # remove duplicates (potential winners are also ties)
+          add_excludeds(result)
+        end
+
+        def add_excludeds(result)
+          excludeds = (@schulze_basic.candidates - result.flatten) # all remaining elements (not in tie, 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 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
+
+        def better_ranking?(a, b)
+          @schulze_basic.ranking[a] > @schulze_basic.ranking[b]
+        end
+
+        def rank_element(el)
+          rank = 0
+          rank -= 100 if @schulze_basic.potential_winners.include?(el)
+          @schulze_basic.beat_couples.each do |b|
+            rank -= 1 if b[0] == el
+          end
+          rank
+        end
+
+        def calculate_classifications
+          start_list = (0..@schulze_basic.ranking.length - 1).to_a
+          start_list.sort! { |e1, e2| rank_element(e1) <=> rank_element(e2) }
+          compute_classifications([], @schulze_basic.potential_winners, @schulze_basic.beat_couples, start_list)
+        end
+
+        def compute_classifications(classif = [], potential_winners, beated_list, start_list)
+          return compute_permutations(classif, start_list) if beated_list.empty?
+          next_list = (classif.empty? && potential_winners.any?) ? potential_winners : start_list
+          add_elements(beated_list, classif, next_list, start_list)
+        end
+
+        def add_elements(beated_list, classif, potential_winners, start_list)
+          potential_winners.each { |element| add_element(classif, beated_list, start_list, element) }
+        end
+
+        def compute_permutations(classif, start_list)
+          start_list.permutation.each do |array|
+            @classifications << classif + array
+            check_limits
+          end
+        end
+
+        def check_limits
+          fail TooManyClassificationsException if @limit_results && @classifications.size > @limit_results
+        end
+
+        def add_element(classif, beated_list, start_list, element)
+          return if beated_list.any? { |c| c[1] == element }
+          classification = classif.clone << element
+          next_start_list = clone_and_delete(start_list, element)
+          if next_start_list.empty?
+            @classifications << classification
+            check_limits
+          else
+            compute_classifications(classification, nil,
+                                    beated_list.clone.delete_if { |c| c[0] == element }, next_start_list)
+          end
+        end
+
+        def clone_and_delete(list, element)
+          list.clone.tap { |l| l.delete(element) }
+        end
+      end
+    end
+  end
+end
+
+class TooManyClassificationsException < StandardError
+end

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

@@ -12,7 +12,7 @@ module Vote
           else
             @vote_matrix = ::Matrix.scalar(@candidate_count, 0).extend(Vote::Matrix)
             insert_vote_array(@vote_list) if vote_list.is_a?(Array)
-            insert_vote_string(@vote_list) if vote_list.is_a?(String)
+            insert_vote_strings(@vote_list) if vote_list.is_a?(String)
           end
         end
 
@@ -26,7 +26,7 @@ module Vote
           @vote_count = va.size
         end
 
-        def insert_vote_string(vs)
+        def insert_vote_strings(vs)
           vote_array = []
 
           vs.split(/\n|\n\r|\r/).each do |voter|
@@ -35,32 +35,35 @@ module Vote
 
             vcount.times do
               tmp = voter.last.split(/;/)
-              tmp2 = []
+              vote_array << extract_vote_string(tmp)
+            end
+          end
 
-              tmp.map! { |e| [e, @candidate_count - tmp.index(e)] }
-              # find equal-weighted candidates
-              tmp.map do |e|
-                if e[0].size > 1
-                  e[0].split(/,/).each do |f|
-                    tmp2 << [f, e[1]]
-                  end # each
-                else
-                  tmp2 << e
-                end # if
-              end # tmp.map
+          insert_vote_array vote_array
+        end
 
-              vote_array << (tmp2.sort.map { |e| e = e[1] }) # order, strip & add
-            end # vcount.times
-          end # vs.split.each
+        def extract_vote_string(tmp)  # array of preferences  [['1, 2'], ['3']. ['4, 5']]
+          tmp2 = []
+          order_and_remap(tmp).
+            map do |e| # find equal-weighted candidates
+            if e[0].size > 1
+              e[0].split(/,/).each { |f| tmp2 << [f, e[1]] }
+            else
+              tmp2 << e
+            end
+          end
+          tmp2.sort.map { |e| e[1] } # order, strip & add
+        end
 
-          insert_vote_array vote_array
+        def order_and_remap(tmp)
+          tmp.map { |e| [e, @candidate_count - tmp.index(e)] }
         end
 
         def insert_vote_file(vf)
           vf.rewind
           @candidate_count = vf.first.strip.to_i # reads first line for count
           @vote_matrix = ::Matrix.scalar(@candidate_count, 0).extend(Vote::Matrix)
-          insert_vote_string vf.read # reads rest of file (w/o line 1)
+          insert_vote_strings vf.read # reads rest of file (w/o line 1)
           vf.close
         end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schulze-vote
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Alessandro Rodi
@@ -26,6 +26,7 @@ files:
 - lib/vote/condorcet.rb
 - lib/vote/condorcet/schulze.rb
 - lib/vote/condorcet/schulze/basic.rb
+- lib/vote/condorcet/schulze/classifications.rb
 - lib/vote/condorcet/schulze/input.rb
 - lib/vote/matrix.rb
 homepage: http://github.com/coorasse/schulze-vote
@@ -48,7 +49,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Schulze method implementation in Ruby (Condorcet voting method)