schulze-vote 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9866e914ebb502be11324a542dfb49de786a7408
-  data.tar.gz: 6ade5e377c2b4e1f01444fd110e535e54df71ac4
+  metadata.gz: 3016d28cfc6bef2976750a075643923e602bd304
+  data.tar.gz: 5dcb2b785be020acc0a8761cda566981867e5486
 SHA512:
-  metadata.gz: 03f614f995678224821bc5d81fa8e5d86945aa0086f767ad96b35d6d577d2d9742177b2bad6fa23ad4e7fa0560e3f17638cf1113d1738e463d40f912d76a2a5a
-  data.tar.gz: 5088baad29d4959dee3df8d4aa232be97090dda1111648a9c388f65dc87e07f4ce6aac55b757e674bbd0f745866424d3eedeb7f69fa43a095ecd2764f89631d5
+  metadata.gz: edb55c862b09981e06dbe6e46e0b5093c622e22e3ceffa9ab2af0254081de28bc78566f91ab8756caded729ac0bc49fdf3a2aaec647a495e7ba45bb371299200
+  data.tar.gz: 7771b158d623a1efbc5ed29705949e7f5a297d7e29b1cbc8d6731a3986d8346e629f3bad7b7efeee54e4682b673b0c22fc56161a1671fca91adc81f27d1e79ac

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2010-2015 Renuo GmbH. https://www.renuo.ch
+Copyright (c) 2010-2016 Alessandro Rodi.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -6,6 +6,7 @@ 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)
+[![Gem Version](https://badge.fury.io/rb/schulze-vote.svg)](https://badge.fury.io/rb/schulze-vote)
 
 ## Develop
 
@@ -13,11 +14,6 @@ a type of the Condorcet voting methods.
 [![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:
-
-* [Schulze method](http://en.wikipedia.org/wiki/Schulze_method) ([deutsch](http://de.wikipedia.org/wiki/Schulze-Methode))
-* [Floyd–Warshall algorithm](http://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm)
-
 ## Install
 
 ``` bash
@@ -34,21 +30,27 @@ gem 'schulze-vote', require: 'schulze_vote'
 
 ``` ruby
 require 'schulze_vote'
-vs = SchulzeBasic.do vote_list, candidate_count
-vs.ranks
+vote_list = <<EOF
+C;A;B
+C;B;A
+A;B;C
+A;C;B
+B;C;A
+B;A;C
+EOF
+schulze_basic = SchulzeBasic.do(vote_list, candidate_count)
+schulze_classifications.classification_with_ties # shows the final classification
 ```
 
-`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..."
+  * Array of Arrays: votes of each voter as weights `[ [1,2,3],[3,2,1],[1,1,2] ]`
+  * String: "A;B;C\nB,A;C\n;3=C;B;A"
   * 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
+* `candidate_count` Integer: number of options
   * **required** for vote_list types of Array and String
-  * _leave empty if vote_list is a File handle!_
+  * leave empty if vote_list is a File
 
 ### String/File format:
 
@@ -84,14 +86,11 @@ Very easy: The reason is, that voters can leave out candidates (they give no spe
 
 So, schulze-vote 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
 
 #### Array
 
-(Only weight values, no letters here! See section "_preference order to weight_ example")
+Only weight values, no letters here
 
 ``` ruby
 require 'schulze_vote'
@@ -99,6 +98,20 @@ vote_list_array = [[3,2,1],[1,3,2],[3,1,2]]
 vs = SchulzeBasic.do vote_list_array, 3
 ```
 
+```
+voter  => A D C B
+
+weight => 4,1,2,3
+
+A is on first position = highest prio == 4
+B is on last position                 == 1
+C is on third position                == 2
+D is on second position               == 3
+```
+
+Next versions will have an automatic Preference-to-Weight algorithm.
+(Internally only integers are used for calculation of ranking.)
+
 #### String
 
 ``` ruby
@@ -120,23 +133,8 @@ require 'schulze_vote'
 vs = SchulzeBasic.do File.open('path/to/vote.list')
 ```
 
-### _preference order to weight_ example
-
-```
-voter  => A D C B
-
-weight => 4,1,2,3
-
-A is on first position = highest prio == 4
-B is on last position                 == 1
-C is on third position                == 2
-D is on second position               == 3
-```
-
-Later versions will have an automatic Preference-to-Weight algorithm.
-(Internally only integers are used for calculation of ranking.)
 
-### _SchulzeBasic_
+### SchulzeBasic
 
 It doesn't matter if you start counting at 0 (zero) or 1 (one).
 
@@ -146,8 +144,16 @@ Internally it will only check if candidate X > candidate Y
 
 Output:
 
-* `.ranks` Array: numbers of total wins for each candidate `[candidate A, candidate B, candidate C, ...]`
+* `.ranking` Array: numbers of total wins for each candidate `[candidate A, candidate B, candidate C, ...]`
 * `.winners_array` Array: set 1 if the candidate is a potential winner `[candidate A, candidate B, candidate C, ...]`
+* `.vote_matrix` Matrix: it contains the pairwise defeats
+* `.play_matrix` Matrix: it contains the strongest paths
+* `.result_matrix` Matrix: it contains the beat pairwise
+* `.beat_couples` Array of Pairs: it contains the beat pairwise in array format
+* `.ties` Array of Array: it contains the ties between candidates
+* `.potential_winners` Array: it contains the possible winners
+
+
 
 ## Example
 
@@ -168,7 +174,7 @@ votestring = <<EOF
 7=D;C;E;B;A
 8=E;B;A;D;C
 EOF
-vs = SchulzeBasic.do votestring, 5
+vs = SchulzeBasic.do(votestring, 5)
 puts_m vs.vote_matrix
 
 #=> [0, 20, 26, 30, 22]
@@ -204,18 +210,17 @@ end
 #=> ["E", "A", "C", "B", "D"]
 ```
 
-which is the same result of the reference above.
 
 ## Classifications
 
-You have a `classifications(limit_results = false)` that you can call.
+You have a `SchulzeClassifications.new(vs).classifications(limit_results = false)` that you can call.
 If the number of results is greater then the `limit_results` parameter then a `TooManyClassificationsException`
 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.
+You have a `SchulzeClassifications.new(vs).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]]
@@ -233,12 +238,18 @@ it will return the following: [[B,D], [A,C]]
 
 ## Problems? Questions?
 
-![Alessandro Rodi](http://www.gravatar.com/avatar/32d80da41830a6e6c1bb3eb977537e3e)
+[![Alessandro Rodi](http://www.gravatar.com/avatar/32d80da41830a6e6c1bb3eb977537e3e)](https://github.com/coorasse)
 
 ## Thanks
 
 Thanks to Christoph Grabo for providing the idea and base code of the gem
 
+## Wikipedia:
+
+* [Schulze method](http://en.wikipedia.org/wiki/Schulze_method) ([deutsch](http://de.wikipedia.org/wiki/Schulze-Methode))
+* [Schulze method examples](https://en.wikipedia.org/wiki/User:MarkusSchulze/Schulze_method_examples)
+* [Floyd-Warshall algorithm](http://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm)
+
 ## Copyright
 
 See LICENSE for further details.

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

@@ -29,6 +29,8 @@ module Vote
           add_excludeds(result)
         end
 
+        private
+
         def add_excludeds(result)
           excludeds = (@schulze_basic.candidates - result.flatten) # all remaining elements (not in tie, not winners)
           excludeds.each do |excluded|
@@ -42,8 +44,6 @@ module Vote
           result
         end
 
-        private
-
         def better_ranking?(a, b)
           @schulze_basic.ranking[a] > @schulze_basic.ranking[b]
         end

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

@@ -5,10 +5,9 @@ module Vote
         def initialize(vote_list, candidate_count = nil)
           @vote_list = vote_list
           @candidate_count = candidate_count
-
+          @candidates_abc = []
           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)
@@ -32,27 +31,30 @@ module Vote
           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(/;/)
               vote_array << extract_vote_string(tmp)
             end
           end
-
           insert_vote_array vote_array
         end
 
-        def extract_vote_string(tmp)  # array of preferences  [['1, 2'], ['3']. ['4, 5']]
+        def extract_vote_string(tmp) # array of preferences  [['1, 2'], ['3']. ['4, 5']]
+          tmp2 = flatten_votes(order_and_remap(tmp))
+          tmp2.map! { |e| [e[0].to_i, e[1]] } if all_numbers?(tmp2)
+          tmp2.sort.map { |e| e[1] } # order, strip & add
+        end
+
+        def flatten_votes(votes)
           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
+          votes.map do |e| # find equal-weighted candidates
+            (e[0].size > 1) ? e[0].split(/,/).each { |f| tmp2 << [f, e[1]] } : tmp2 << e
           end
-          tmp2.sort.map { |e| e[1] } # order, strip & add
+          tmp2
+        end
+
+        def all_numbers?(array)
+          array.map { |e| e[0] }.all? { |el| /\A\d+\z/.match(el) }
         end
 
         def order_and_remap(tmp)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schulze-vote
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Alessandro Rodi