vote-schulze 0.1.0 → 0.2.0

data/Gemfile

@@ -1,13 +1,7 @@
 source "http://rubygems.org"
-# Add dependencies required to use your gem here.
-# Example:
-#   gem "activesupport", ">= 2.3.5"
-
-# Add dependencies to develop your gem here.
-# Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "rspec", "~> 2.3.0"
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.6.0"
-  gem "rcov", ">= 0"
+  gem "rspec", "~> 2.3.0"
 end
+

data/Gemfile.lock

@@ -8,7 +8,6 @@ GEM
       git (>= 1.2.5)
       rake
     rake (0.8.7)
-    rcov (0.9.9)
     rspec (2.3.0)
       rspec-core (~> 2.3.0)
       rspec-expectations (~> 2.3.0)
@@ -24,5 +23,4 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.0.0)
   jeweler (~> 1.6.0)
-  rcov
   rspec (~> 2.3.0)

data/README.md

@@ -2,6 +2,10 @@
 
 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.
 
+**Very alpha! Only basic functionality. No tests yet!**
+
+(If you want to write the tests: fork, write, test, push request - Thanks!)
+
 Wikipedia:
 
 * [Schulze method](http://en.wikipedia.org/wiki/Schulze_method) ([deutsch](http://de.wikipedia.org/wiki/Schulze-Methode))
@@ -17,18 +21,97 @@ gem install vote-schulze
 
 ``` ruby
 require 'vote-schulze'
-vs = SchulzeBasic.do candidate_count, vote_list
-vs.ranking_array
+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!
 
 Input:
 
+* `vote_list`
+  * Array of Arrays: votes of each voter as weights `[ [A,B,C,...],[A,B,C,...],[A,B,C,...] ]`
+  * String: "A;B;C\nA;B;C\n;3=A;B;C..."
+  * File: first line **must** be a single integer, following lines like vote_list type String (see vote lists under `examples` directory)
 * `candidate_count` Integer: number of candidates
-* `vote_list` Array of Arrays: votes of each voter as weights `[ [A,B,C,...],[A,B,C,...],[A,B,C,...] ]`
+  * **required** for vote_list types of Array and String
+  * _leave empty if vote_list is a File handle!_
+
+### String/File format:
+
+A typical voters line looks like this:
+
+```
+A;B;C;D;E;F
+```
+
+You also can say that _n_ voters have the same preferences:
+
+```
+n=F;E;D;C;B;A
+```
+
+where _n_ is an integer value for the count.
+
+Also it's possible to say that a voter has candidates equally weighted:
+
+```
+A,B;C,D;E,F
+```
+
+which means, that A + B, C + D and E + F are on the same weight level.
+
+Here only 3 weight levels are used: (A,B) = 3, (C,D) = 2, (E,F) = 1
+
+### Why I must write the candidate count in the first line of the vote file?
+
+_or: Why I must give a candidate count value for Array/String inputs?_
+
+Very easy: The reason is, that voters can leave out candidates (they give no special preferences).
+
+So, vote-schulze needs to know, how many real candidates are in the voting process.
+
+Okay, for Array inputs it's currently a little bit overhead, because the voters array normally should have the size of the candidates count.
+See it as an visual reminder while coding with this gem.
+
+### Examples
 
-preference order to weight example:
+#### Array
+
+(Only weight values, no letters here! See section "_preference order to weight_ example")
+
+``` ruby
+require 'vote-schulze'
+vote_list_array = [[3,2,1],[1,3,2],[3,1,2]]
+vs = SchulzeBasic.do vote_list_array, 3
+vs.ranks_abc #=> result
+```
+
+#### String
+
+``` ruby
+require 'vote-schulze'
+vote_list_string = <<EOF
+A;B;C
+B;C;A
+A;C;B
+A,C,B
+4=C;A;B
+EOF
+vs = SchulzeBasic.do vote_list_string, 3
+vs.ranks_abc #=> result
+```
+
+#### File
+
+``` ruby
+require 'vote-schulze'
+vs = SchulzeBasic.do File.open('path/to/vote.list')
+vs.ranks_abc #=> result
+```
+
+### _preference order to weight_ example
 
 ```
 voter  => A D C B
@@ -56,6 +139,23 @@ Output:
 
 * `.ranking_array` Array: numbers of total wins for each candidate `[candidate A, candidate B, candidate C, ...]`
 
+## Example
+
+Reference calculation: [Schulze Methode | blog.cgiesel.de (german)](http://blog.cgiesel.de/schulze-methode/)
+
+Example file under `examples/vote4.list`
+
+Result should be:
+``` ruby
+sb = SchulzeBasic.do File.open('../examples/vote4.list')
+sb.rank_abc
+#=> ["C:1", "D:2", "B:3", "A:4"]
+```
+
+which is the same result of the reference above.
+
+The result strings are always in format `Candidate:Position`, because it's possible that multiple candidates can be on the same rank.
+
 ## Contributing to vote-schulze
 
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet

data/Rakefile

@@ -18,7 +18,7 @@ Jeweler::Tasks.new do |gem|
   gem.homepage = "http://github.com/asaaki/vote-schulze"
   gem.license = "MIT"
   gem.summary = %Q{Schulze method implementation in Ruby (Condorcet voting method)}
-  gem.description = %Q{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.}
+  gem.description = %Q{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.}
   gem.email = "chris@dinarrr.com"
   gem.authors = ["Christoph Grabo"]
   # dependencies defined in Gemfile
@@ -31,11 +31,6 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
 task :default => :spec
 
 require 'rake/rdoctask'

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/examples/vote4.list

@@ -0,0 +1,7 @@
+4
+3=a;c;d;b
+9=b;a;c;d
+8=c;d;a;b
+5=d;a;b;c
+5=d;b;c;a
+

data/examples/vote6.list

@@ -0,0 +1,44 @@
+6
+2=A;B;C;D;E;F
+3=A,B;C,D;E,F
+F;C;D;A;B;E
+A;D;C;F;E;B
+F;E;D;C;B;A
+D;E;A,B;C;F
+B;A;C;D;E;F
+9=C;A;F,E;B;D
+D;A;E;F;C;B
+E;B;F;D;C;A
+F;C;D;A,E,B
+6=A;D;E;B;F;C
+B;E;C;F;A;D
+C;F;A,B;D;E
+D;A;B;E;C;F
+E;B,F;C;D;A
+F;C;A;D;E;B
+A;D;B;E;F;C
+B,E;F;A;C;D
+2=C;F;D;B;A;E
+D;A,E,B;C;F
+E;B;C;F;D;A
+F;C;D;A;E;B
+E;D;C,F,B;A
+D;E;B;F;A;C
+3=C;F;A;E;B;D
+B;A;D;C,F;E
+A;B;D;E;C;F
+A;C;F;B;D,E
+A;D;E;F;C;B
+B;E;D;C;F;A
+B;F;C,E,A,D
+2=C;A;B;D;E;F
+D;B,F,E;C;A
+D;C;A;F;E;B
+E,D;F;A;B;C
+E;F;A;B;C;D
+F;E;B;A;C;D
+F;A,D,C;B;E
+A;B;C;E;D;F
+B;C;F;A;D;E
+2=C;D;E;B,F;A
+

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

@@ -6,40 +6,32 @@ module Vote
 
       class Basic
 
-        def initialize
-          #self
-        end
-
-        def load candidate_count, vote_matrix
-
-          @candidate_count = candidate_count
-
-          @vote_matrix = vote_matrix.is_a?(Vote::Condorcet::Schulze::Input) ? \
-            vote_matrix.matrix : \
+        def load vote_matrix, candidate_count=nil
+          input = vote_matrix.is_a?(Vote::Condorcet::Schulze::Input) ? \
+            vote_matrix : \
             Vote::Condorcet::Schulze::Input.new(
-              candidate_count,
-              vote_matrix
-            ).matrix
-
+              vote_matrix,
+              candidate_count
+            )
+          @vote_matrix = input.matrix
+          @candidate_count = input.candidates
+          @vote_count = input.voters
           self
         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]
-              end
-            end
-          end
-
+              end #loop3
+            end #loop2
+          end #loop1
           #step 2: find strongest pathes
           @candidate_count.times do |i|
             @candidate_count.times do |j|
@@ -51,38 +43,34 @@ module Vote
                   @play_matrix[j,k],
                   [ @play_matrix[j,i], @play_matrix[i,k] ].min
                   ].max
-              end
-            end
-          end
-
-          self
-        end
+              end #loop3
+            end #loop2
+          end #loop1
+        end #def
 
 
         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
-
-          self
         end
 
-
         def rank
+          @ranking = @result_matrix.
+            row_vectors.map { |e| e.inject(0) { |s,v| s += v } }
+        end
 
-          @ranking = Array.new(@candidate_count,0)
-
-          @result_matrix.row_vectors.each_with_index do |v,i|
-            v.to_a.map do |e|
-              @ranking[i] += e
-            end
-          end
-
-          self
+        def rank_abc
+          r = @ranking
+          rmax = r.max
+          abc = r.map{|e|
+            [e,(r.index(e)+65).chr] # => [int,letter]
+            }.
+            sort.reverse. # bring in correct order
+            map{|e| "#{e[1]}:#{rmax-e[0]+1}" } # => "letter:int"
+          @ranking_abc = abc
         end
 
         public
@@ -91,6 +79,7 @@ module Vote
           play
           result
           rank
+          rank_abc
         end
 
         def vote_matrix
@@ -102,15 +91,20 @@ module Vote
         def result_matrix
           @result_matrix
         end
-        def ranking_array
+        def ranks
           @ranking
         end
-
+        def ranks_abc
+          @ranking_abc
+        end
+        def voters
+          @vote_count
+        end
 
         # All-in-One class method to get a calculated SchulzeBasic object
-        def self.do candidate_count, vote_matrix
+        def self.do vote_matrix, candidate_count=nil
           instance = new
-          instance.load candidate_count, vote_matrix
+          instance.load vote_matrix, candidate_count
           instance.run
           instance
         end

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

@@ -6,12 +6,19 @@ module Vote
 
       class Input
 
-        @vote_matrix = nil
+        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
 
-        def initialize candidate_count, vote_list
-          @vote_matrix = ::Matrix.scalar(candidate_count,0).extend(Vote::Matrix)
-          insert_vote_array(vote_list) if vote_list.is_a?(Array)
-          insert_vote_file(vote_list) if vote_list.is_a?(File)
         end
 
         def insert_vote_array va
@@ -21,20 +28,59 @@ module Vote
               @vote_matrix[x,y] += 1 if vote[x]>vote[y]
             end
           end
+          @vote_count = va.size
         end
 
-        def insert_vote_list vl
-          #...
+        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

data/vote-schulze.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{vote-schulze}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Christoph Grabo"]
-  s.date = %q{2011-05-19}
-  s.description = %q{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.}
+  s.date = %q{2011-05-22}
+  s.description = %q{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.}
   s.email = %q{chris@dinarrr.com}
   s.extra_rdoc_files = [
     "LICENSE.txt",
@@ -26,6 +26,8 @@ Gem::Specification.new do |s|
     "README.md",
     "Rakefile",
     "VERSION",
+    "examples/vote4.list",
+    "examples/vote6.list",
     "lib/vote-schulze.rb",
     "lib/vote.rb",
     "lib/vote/condorcet.rb",
@@ -48,21 +50,18 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.0"])
-      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
     else
-      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
       s.add_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
-      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
     end
   else
-    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
-    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vote-schulze
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,23 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-05-19 00:00:00.000000000 +02:00
+date: 2011-05-22 00:00:00.000000000 +02:00
 default_executable: 
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &26515360 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 2.3.0
-  type: :development
-  prerelease: false
-  version_requirements: *26515360
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &26514880 !ruby/object:Gem::Requirement
+  requirement: &28284620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +22,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *26514880
+  version_requirements: *28284620
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &26514400 !ruby/object:Gem::Requirement
+  requirement: &28284140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,20 +33,20 @@ dependencies:
         version: 1.6.0
   type: :development
   prerelease: false
-  version_requirements: *26514400
+  version_requirements: *28284140
 - !ruby/object:Gem::Dependency
-  name: rcov
-  requirement: &26513920 !ruby/object:Gem::Requirement
+  name: rspec
+  requirement: &28283660 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.3.0
   type: :development
   prerelease: false
-  version_requirements: *26513920
-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.
+  version_requirements: *28283660
+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.
 email: chris@dinarrr.com
 executables: []
 extensions: []
@@ -74,6 +63,8 @@ files:
 - README.md
 - Rakefile
 - VERSION
+- examples/vote4.list
+- examples/vote6.list
 - lib/vote-schulze.rb
 - lib/vote.rb
 - lib/vote/condorcet.rb
@@ -101,7 +92,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2256632431419553553
+      hash: -2878999466654239120
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: