Add "hash-random" method.

This method takes all the ballot data and runs it through a hash
function, ordering candidates according to the hash value when
setting the first double of the data to the candidate number. In
essence, it's a reproducible version of random candidate, and as
such extremely manipulable.

It's useful for finding bounds on manipulability of certain sets
or other methods over all possible ways to break ties.

Author: kristomu

CMakeLists.txt

@@ -136,6 +136,7 @@ add_library(qe_singlewinner_methods
 	src/singlewinner/experimental/rmr1.cc
 	src/singlewinner/fpc.cc
 	src/singlewinner/gradual_c_b.cc
+	src/singlewinner/hash.cc
 	src/singlewinner/meta/chain_climbing.cc
 	src/singlewinner/meta/benham.cc
 	src/singlewinner/meta/comma.cc

src/lib/spookyhash/SpookyV2.h

@@ -26,6 +26,8 @@
 // slower than MD5.
 //
 
+#pragma once
+
 #include <stddef.h>
 
 #ifdef _MSC_VER

src/singlewinner/all.h

@@ -5,6 +5,7 @@
 
 #include "fpc.h"
 #include "gradual_c_b.h"
+#include "hash.h"
 #include "no_elimination_irv.h"
 #include "quick_runoff.h"
 #include "young.h"

src/singlewinner/hash.cc

@@ -0,0 +1,41 @@
+#include "hash.h"
+
+std::pair<ordering, bool> hash_random_cand::elect_inner(
+	const election_t & papers,
+	const std::vector<bool> & hopefuls, int num_candidates,
+	cache_map * cache, bool winner_only) const {
+
+	// Dump the ballot data to a double vector that
+	// we'll later read into the hash function.
+	std::vector<double> ballot_byte_rep;
+	// Reserve a spot for the candidate number.
+	ballot_byte_rep.push_back(-1);
+
+	for (const ballot_group & bg: papers) {
+		ballot_byte_rep.push_back(bg.get_weight());
+		for (const candscore & cs: bg.contents) {
+			ballot_byte_rep.push_back(cs.get_score());
+			ballot_byte_rep.push_back(cs.get_candidate_num());
+		}
+	}
+
+	// Get the "score" of each candidate by setting the first
+	// element to the candidate number. Highest score wins.
+
+	ordering out;
+
+	for (size_t candidate = 0; candidate < (size_t)num_candidates;
+		++candidate) {
+
+		ballot_byte_rep[0] = candidate;
+
+		size_t score = hasher.Hash64(
+				ballot_byte_rep.data(),
+				sizeof(double) * ballot_byte_rep.size(),
+				0);
+
+		out.insert(candscore(candidate, score));
+	}
+
+	return (std::pair<ordering, bool>(out, false));
+}

src/singlewinner/hash.h

@@ -0,0 +1,30 @@
+// This method performs a hashing operation on the input ballot set, and
+// orders the winners according to the output.
+// It thus fails just about every property (as well as neutrality and
+// symmetry) and is maximally manipulable. It's basically random
+// candidate without actual randomness.
+// The only point of the method is to prove lower bounds about
+// compositions, e.g. the maximal manipulability of something that
+// elects from the resistant set.
+
+#pragma once
+
+#include "method.h"
+#include "lib/spookyhash/SpookyV2.h"
+
+class hash_random_cand : public election_method {
+
+	private:
+		mutable SpookyHash hasher;
+
+		std::pair<ordering, bool> elect_inner(
+			const election_t & papers,
+			const std::vector<bool> & hopefuls,
+			int num_candidates, cache_map * cache,
+			bool winner_only) const;
+
+	public:
+		std::string name() const {
+			return "Hash-random candidate";
+		}
+};