schulze 0.0.1

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+bin/autospec
+bin/htmldiff
+bin/ldiff
+bin/rspec

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@schulze --create

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Bradley Grzesiak
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# Schulze
+
+Calculate the winner of a Schulze method election.
+
+This gem is intended for command-line use, though it may work alright as a library.
+
+## Warning!
+
+This program was designed against a particular use-case... specifically, candidates must have unique last names (where last name is defined as the last element of a `split`). This was done because data on first names tends to be unclean (e.g., "Tim" & "Timothy" are the same person).
+
+## Installation
+
+Install it:
+
+    $ gem install schulze
+
+## Usage
+
+Collect ballots in a directory. Each ballot should be a file in the form:
+
+    1 A
+    2 B
+    3 C1
+    3 C2
+    4 D
+
+Then, run the program:
+
+    $ schulze directory/to/ballots/*.txt
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/schulze

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/schulze', __FILE__)
+
+results = Schulze::Election.perform_for_dir_glob(ARGV[1...ARGV.count])
+
+results.each_with_index do |line, idx|
+  puts("%3d %s" % [idx+1, line.inspect])
+end

data/lib/schulze.rb

@@ -0,0 +1,3 @@
+require File.expand_path('../schulze/version', __FILE__)
+
+require File.expand_path('../schulze/election', __FILE__)

data/lib/schulze/ballot.rb

@@ -0,0 +1,49 @@
+require 'matrix'
+
+module Schulze
+  class Ballot
+    def self.new_from_filename filename
+      new.tap do |ballot|
+        File.open(filename, 'r') do |io|
+          io.each_line do |line|
+            chunks = line.split
+            ballot.add_choice(chunks.first.to_i, chunks.last)
+          end
+        end
+      end
+    end
+
+    def initialize
+      @choices = Hash.new(1e9)
+    end
+
+    def add_choice ordering, name
+      @choices[name] = ordering
+    end
+
+    def candidates
+      @choices.keys
+    end
+
+    def preference_matrix all_candidates
+      matrix = Matrix.zero(all_candidates.size)
+      Matrix.build(all_candidates.size) do |row, col|
+        if row == col
+          0
+        else
+          a, b = all_candidates[row], all_candidates[col]
+          prefers?(a, b) ? 1 : 0
+        end
+      end
+    end
+
+    def prefers? a, b
+      @choices[a] < @choices[b]
+    end
+
+    def to_s
+      "Ballot:\n" + @choices.to_a.map(&:inspect).join("\n")
+    end
+
+  end
+end

data/lib/schulze/election.rb

@@ -0,0 +1,91 @@
+require File.expand_path('../ballot', __FILE__)
+require 'set'
+
+module Schulze
+  class Election
+
+    def self.perform_for_dir_glob dir_glob
+      election = new
+      dir_glob.each do |filename|
+        election << Ballot.new_from_filename(filename)
+      end
+      election.results
+    end
+
+    def initialize
+      @ballots = []
+      @candidates = Set.new
+    end
+
+    def << ballot
+      @ballots << ballot
+      @candidates.merge ballot.candidates
+    end
+
+    def results
+      candidate_array = @candidates.to_a.sort
+      pairwise = generate_pairwise_preferences candidate_array
+      path_strengths = generate_path_strengths pairwise
+
+      if !(defined?(SILENCE) && SILENCE)
+        path_strengths.each_with_index do |row, idx|
+          puts("%20s %s" % [candidate_array[idx], row.inspect])
+        end
+      end
+
+      generate_orderings candidate_array, path_strengths
+    end
+
+    private
+
+    def generate_pairwise_preferences candidates
+      @ballots.inject(::Matrix.zero(@candidates.count)) do |memo, ballot|
+        memo + ballot.preference_matrix(candidates)
+      end
+    end
+
+    def generate_path_strengths d
+      size = d.row_size
+      paths = Matrix.build(size) do |row, col|
+        if row == col
+          0
+        else
+          d[row,col] > d[col,row] ? d[row,col] : 0
+        end
+      end
+      ret = d.to_a
+      0.upto(size-1) do |i|
+        0.upto(size-1) do |j|
+          unless i == j
+            0.upto(size-1) do |k|
+              if i != k && j != k
+                ret[j][k] = [ret[j][k], [ret[j][i], ret[i][k]].min].max
+              end
+            end
+          end
+        end
+      end
+      ret
+    end
+
+    def generate_orderings candidate_array, path_strengths
+      sorted = candidate_array.sort do |a, b|
+        i, j = candidate_array.index(a), candidate_array.index(b)
+        path_strengths[j][i] <=> path_strengths[i][j]
+      end
+      ret = [[sorted.shift]]
+      while not sorted.empty?
+        last_addition = ret.last.last
+        next_candidate = sorted.shift
+        i, j = candidate_array.index(last_addition), candidate_array.index(next_candidate)
+        if path_strengths[i][j] == path_strengths[j][i]
+          ret.last << next_candidate
+        else
+          ret << [next_candidate]
+        end
+      end
+      ret
+    end
+
+  end
+end

data/lib/schulze/version.rb

@@ -0,0 +1,3 @@
+module Schulze
+  VERSION = "0.0.1"
+end

data/schulze.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/schulze/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Bradley Grzesiak"]
+  gem.email         = ["brad@bendyworks.com"]
+  gem.description   = %q{The Schulze Method, for ruby}
+  gem.summary       = %q{The Schulze Method is a Condorcet voting method that computes a list of candidates sorted by the electorate's preferences}
+  gem.homepage      = "https://github.com/madisonium/schulze"
+
+  gem.executables   = ['schulze']
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "schulze"
+  gem.require_paths = ["lib"]
+  gem.version       = Schulze::VERSION
+
+  gem.add_development_dependency 'rspec'
+end

data/spec/acceptance/wikipedia_spec.rb

@@ -0,0 +1,105 @@
+# See: http://en.wikipedia.org/w/index.php?title=User:MarkusSchulze/Schulze_method_examples&oldid=383750275
+
+require 'schulze'
+require 'fileutils'
+
+SILENCE = true
+
+describe 'schulze voting method' do
+  let(:tmp_dir) { '/tmp/schulze' }
+  let(:candidate_count) { ballots.keys.first.length }
+
+  after do
+    FileUtils.rm_rf(tmp_dir)
+  end
+
+  before do
+    FileUtils.mkdir(tmp_dir)
+
+    ballots.each_pair do |ordering, count|
+      1.upto(count) do |idx|
+        File.open("#{tmp_dir}/#{ordering}.#{idx}.txt", 'w') do |f|
+          pairs = (1..candidate_count).zip(ordering.split(''))
+          f.puts pairs.map{|x| "#{x[0]} #{x[1]}"}.join("\n")
+        end
+      end
+    end
+
+  end
+
+
+
+
+  shared_examples_for 'standard schulze' do
+    it 'works' do
+      result = Schulze::Election.perform_for_dir_glob Dir["#{tmp_dir}/*.txt"]
+      result.should == expected
+    end
+  end
+
+
+
+
+  describe 'example 1' do
+    let(:ballots) { {
+        'ACBED' => 5,
+        'ADECB' => 5,
+        'BEDAC' => 8,
+        'CABED' => 3,
+        'CAEBD' => 7,
+        'CBADE' => 2,
+        'DCEBA' => 7,
+        'EBADC' => 8
+      }
+    }
+    let(:expected) { [['E'], ['A'], ['C'], ['B'], ['D']] }
+    it_should_behave_like 'standard schulze'
+  end
+
+  describe 'example 2' do
+    let(:ballots) { {
+        'ACBD' => 5,
+        'ACDB' => 2,
+        'ADCB' => 3,
+        'BACD' => 4,
+        'CBDA' => 3,
+        'CDBA' => 3,
+        'DACB' => 1,
+        'DBAC' => 5,
+        'DCBA' => 4
+      }
+    }
+    let(:expected) { [['D'], ['A'], ['C'], ['B']] }
+    it_should_behave_like 'standard schulze'
+  end
+
+  describe 'example 3' do
+    let(:ballots) { {
+        'ABDEC' => 3,
+        'ADEBC' => 5,
+        'ADECB' => 1,
+        'BADEC' => 2,
+        'BDECA' => 2,
+        'CABDE' => 4,
+        'CBADE' => 6,
+        'DBECA' => 2,
+        'DECAB' => 5
+      }
+    }
+    let(:expected) { [['B'], ['A'], ['D'], ['E'], ['C']] }
+    it_should_behave_like 'standard schulze'
+  end
+
+  describe 'example 4', :pending => 'does not handle degenerate cases well' do
+    let(:ballots) { {
+        'ABCD' => 3,
+        'DABC' => 2,
+        'DBCA' => 2,
+        'CBDA' => 2
+      }
+    }
+    let(:expected) { [['B'], ['C'], ['D'], ['A']] }
+    it_should_behave_like 'standard schulze'
+  end
+
+end

data/spec/lib/schulze/ballot_spec.rb

@@ -0,0 +1,25 @@
+require 'schulze/ballot'
+require 'set'
+require 'matrix'
+
+describe Schulze::Ballot do
+  describe 'preference_matrix' do
+    example '4 candidates, 4 choices' do
+      expected = ::Matrix[[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 1], [0, 0, 0, 0]]
+      ballot = Schulze::Ballot.new
+      ballot.add_choice 1, 'A'
+      ballot.add_choice 2, 'B'
+      ballot.add_choice 3, 'C'
+      ballot.add_choice 4, 'D'
+      result = ballot.preference_matrix %w(A B C D)
+      result.should == expected
+    end
+    example '4 candidates, 1 choice' do
+      expected = ::Matrix[[0, 1, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
+      ballot = Schulze::Ballot.new
+      ballot.add_choice 1, 'A'
+      result = ballot.preference_matrix %w(A B C D)
+      result.should == expected
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: schulze
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Bradley Grzesiak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70262322232300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70262322232300
+description: The Schulze Method, for ruby
+email:
+- brad@bendyworks.com
+executables:
+- schulze
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/schulze
+- lib/schulze.rb
+- lib/schulze/ballot.rb
+- lib/schulze/election.rb
+- lib/schulze/version.rb
+- schulze.gemspec
+- spec/acceptance/wikipedia_spec.rb
+- spec/lib/schulze/ballot_spec.rb
+homepage: https://github.com/madisonium/schulze
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: The Schulze Method is a Condorcet voting method that computes a list of candidates
+  sorted by the electorate's preferences
+test_files:
+- spec/acceptance/wikipedia_spec.rb
+- spec/lib/schulze/ballot_spec.rb