schulze-vote 2.0.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07f4360d75e0227e1074c3bdb3ecbb47cf692759
-  data.tar.gz: b79fb40072365731ae79c09ee7c9013043467af6
+  metadata.gz: 0f1a89377c52c746f04598f5af4202130d6276e4
+  data.tar.gz: 55fab398da85310889bee1304c3b099d9a6a6554
 SHA512:
-  metadata.gz: 78bcc2f6faade7f90a72bdd46cbfc059d4f1921be199dd5ce8ab73943cc1e9d80d293f820feba645e5749afb7c858641d721dbf250cefbad4fbcb42947124234
-  data.tar.gz: 7b72e21f89120d106290e6a4f0b8f64db88210e7f5fea5fbf427b1af182948ab9fa3a74c50e53a6fb80ecc3113b3fc65e5015f014e9e5a5c73f2e3000ec1427b
+  metadata.gz: 0ee33a934d33321ea22e2f35bad75fa1c9b462b0b4e9c141b7e0709eabe8a3d547fba852526b70a9de395afa12fa55a30b3e4b60dc553b3aeaf95cb2e96a8fee
+  data.tar.gz: b7475ff5206ebd7f19166aaf89a4cb88c3e37bd7a2ae15e60d3b4b7b35bc91cab5da1e56541b7feba5b1aebf568c805bbf2e9864d2bd7bb0acfbf7912aa2e289

data/lib/vote/condorcet.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+module Vote
+  module Condorcet
+    autoload :Schulze, 'vote/condorcet/schulze'
+  end
+end

data/lib/vote/condorcet/schulze.rb

@@ -0,0 +1,8 @@
+module Vote
+  module Condorcet
+    module Schulze
+      autoload :Input, 'vote/condorcet/schulze/input'
+      autoload :Basic, 'vote/condorcet/schulze/basic'
+    end
+  end
+end

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

@@ -0,0 +1,188 @@
+module Vote
+  module Condorcet
+    module Schulze
+      class Basic
+        # All-in-One class method to get a calculated SchulzeBasic object
+        def self.do(vote_matrix, candidate_count = nil)
+          instance = new
+          instance.load vote_matrix, candidate_count
+          instance.run
+          instance
+        end
+
+        def load(vote_matrix, candidate_count = nil)
+          input = if vote_matrix.is_a?(Vote::Condorcet::Schulze::Input)
+                    vote_matrix
+                  else
+                    Vote::Condorcet::Schulze::Input.new(
+                      vote_matrix,
+                      candidate_count
+                    )
+                  end
+          @vote_matrix = input.matrix
+          @candidate_count = input.candidates
+          @vote_count = input.voters
+          self
+        end
+
+        def run
+          play
+          result
+          calculate_winners
+          rank
+        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
+
+        def classifications
+          @classifications ||= calculate_classifications
+        end
+
+        private
+
+        def play
+          @play_matrix = ::Matrix.scalar(@candidate_count, 0).extend(Vote::Matrix)
+          # step 1: find matches with wins
+          @candidate_count.times do |i|
+            @candidate_count.times do |j|
+              next if i == j
+              if @vote_matrix[i, j] > @vote_matrix[j, i]
+                @play_matrix[i, j] = @vote_matrix[i, j]
+              else
+                @play_matrix[i, j] = 0
+              end
+            end
+          end
+
+          # step 2: 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
+              end
+            end
+          end
+        end
+
+        def result
+          @result_matrix = ::Matrix.scalar(@candidate_count, 0).extend(Vote::Matrix)
+          @result_matrix.each_with_index do |e, x, y|
+            next if x == y
+            @result_matrix[x, y] = e + 1 if @play_matrix[x, y] > @play_matrix[y, x]
+          end
+        end
+
+        def calculate_winners
+          @winners_array = Array.new(@candidate_count, 0)
+          @winners_array.each_with_index do |_el, idx|
+            row = @play_matrix.row(idx)
+            column = @play_matrix.column(idx)
+            if row.each_with_index.all? { |r, index| r >= column[index] }
+              @winners_array[idx] = 1
+            end
+          end
+        end
+
+        def rank
+          @ranking = @result_matrix.
+            row_vectors.map { |e| e.inject(0) { |s, v| s += v } }
+        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
+        end
+
+        def calculate_beat_couples
+          @beat_couples = []
+          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
+            end
+          end
+          @beat_couples
+        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
+          calculate_potential_winners
+          calculate_beat_couples
+
+          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)
+          classifications
+        end
+
+        def compute_classifications(classifications, classif = [], potential_winners, beated_list, start_list)
+          if beated_list.empty?
+            start_list.permutation.each do |array|
+              classifications << classif + array
+            end
+          else
+            if classif.empty? && potential_winners.any?
+              potential_winners.each do |element|
+                add_element(classifications, classif, nil, beated_list, start_list, element)
+              end
+            else
+              start_list.each do |element|
+                add_element(classifications, classif, nil, beated_list, start_list, element)
+              end
+            end
+          end
+        end
+
+        def add_element(classifications, classif, _potential_winners, beated_list, start_list, element)
+          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
+          else
+            compute_classifications(classifications, classification, nil, next_beated_list, next_start_list)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module Vote
+  module Condorcet
+    module Schulze
+      class Input
+        def initialize(vote_list, candidate_count = nil)
+          @vote_list = vote_list
+          @candidate_count = candidate_count
+
+          if @candidate_count.nil?
+            insert_vote_file(@vote_list) if vote_list.is_a?(File)
+
+          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)
+          end
+        end
+
+        def insert_vote_array(va)
+          va.each do |vote|
+            @vote_matrix.each_with_index do |_e, x, y|
+              next if x == y
+              @vote_matrix[x, y] += 1 if vote[x] > vote[y]
+            end
+          end
+          @vote_count = va.size
+        end
+
+        def insert_vote_string(vs)
+          vote_array = []
+
+          vs.split(/\n|\n\r|\r/).each do |voter|
+            voter = voter.split(/=/)
+            vcount = (voter.size == 1) ? 1 : voter[0].to_i
+
+            vcount.times do
+              tmp = voter.last.split(/;/)
+              tmp2 = []
+
+              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
+
+              vote_array << (tmp2.sort.map { |e| e = e[1] }) # order, strip & add
+            end # vcount.times
+          end # vs.split.each
+
+          insert_vote_array vote_array
+        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)
+          vf.close
+        end
+
+        def matrix
+          @vote_matrix
+        end
+
+        def candidates
+          @candidate_count
+        end
+
+        def voters
+          @vote_count
+        end
+      end
+    end
+  end
+end

data/lib/vote/matrix.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+
+# extend matrix with method []=(i,j,v)
+# usage: m = ::Matrix.scalar(size,value).extend(Vote::Matrix)
+
+module Vote
+  module Matrix
+    def []=(i, j, v)
+      @rows[i][j] = v
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schulze-vote
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Alessandro Rodi
@@ -23,6 +23,11 @@ files:
 - README.md
 - lib/schulze_vote.rb
 - lib/vote.rb
+- lib/vote/condorcet.rb
+- lib/vote/condorcet/schulze.rb
+- lib/vote/condorcet/schulze/basic.rb
+- lib/vote/condorcet/schulze/input.rb
+- lib/vote/matrix.rb
 homepage: http://github.com/coorasse/schulze-vote
 licenses:
 - MIT