Initial PJR implementation.

frame/staking/src/lib.rs

@@ -2617,8 +2617,8 @@ impl<T: Trait> Module<T> {
 		// write new results.
 		<QueuedElected<T>>::put(ElectionResult {
 			elected_stashes: winners,
-			compute,
 			exposures,
+			compute,
 		});
 		QueuedScore::put(submitted_score);
 

primitives/npos-elections/src/lib.rs

@@ -18,10 +18,10 @@
 //! - [`seq_phragmen`]: Implements the Phragmén Sequential Method. An un-ranked, relatively fast
 //!   election method that ensures PJR, but does not provide a constant factor approximation of the
 //!   maximin problem.
-//! - [`phragmms`]: Implements a hybrid approach inspired by Phragmén which is executed faster but
+//! - [`phragmms`](phragmms::phragmms): Implements a hybrid approach inspired by Phragmén which is executed faster but
 //!   it can achieve a constant factor approximation of the maximin problem, similar to that of the
 //!   MMS algorithm.
-//! - [`balance_solution`]: Implements the star balancing algorithm. This iterative process can push
+//! - [`balance`](balancing::balance): Implements the star balancing algorithm. This iterative process can push
 //!   a solution toward being more `balances`, which in turn can increase its score.
 //!
 //! ### Terminology
@@ -92,18 +92,20 @@ mod mock;
 #[cfg(test)]
 mod tests;
 
-mod phragmen;
-mod balancing;
-mod phragmms;
-mod node;
-mod reduce;
-mod helpers;
+pub mod phragmen;
+pub mod balancing;
+pub mod phragmms;
+pub mod node;
+pub mod reduce;
+pub mod helpers;
+pub mod pjr;
 
 pub use reduce::reduce;
 pub use helpers::*;
 pub use phragmen::*;
 pub use phragmms::*;
 pub use balancing::*;
+pub use pjr::*;
 
 // re-export the compact macro, with the dependencies of the macro.
 #[doc(hidden)]
@@ -189,6 +191,12 @@ pub struct Candidate<AccountId> {
 	round: usize,
 }
 
+impl<AccountId> Candidate<AccountId> {
+	pub fn to_ptr(self) -> CandidatePtr<AccountId> {
+		Rc::new(RefCell::new(self))
+	}
+}
+
 /// A vote being casted by a [`Voter`] to a [`Candidate`] is an `Edge`.
 #[derive(Clone, Default)]
 pub struct Edge<AccountId> {
@@ -233,6 +241,19 @@ impl<A: IdentifierT> std::fmt::Debug for Voter<A> {
 }
 
 impl<AccountId: IdentifierT> Voter<AccountId> {
+	/// Create a new `Voter`.
+	pub fn new(who: AccountId) -> Self {
+		Self { who, ..Default::default() }
+	}
+
+
+	/// Returns `true` if `self` votes for `target`.
+	///
+	/// Note that this does not take into account if `target` is elected (i.e. is *active*) or not.
+	pub fn votes_for(&self, target: &AccountId) -> bool {
+		self.edges.iter().any(|e| &e.who == target)
+	}
+
 	/// Returns none if this voter does not have any non-zero distributions.
 	///
 	/// Note that this might create _un-normalized_ assignments, due to accuracy loss of `P`. Call
@@ -625,7 +646,7 @@ pub(crate) fn setup_inputs<AccountId: IdentifierT>(
 		.enumerate()
 		.map(|(idx, who)| {
 			c_idx_cache.insert(who.clone(), idx);
-			Rc::new(RefCell::new(Candidate { who, ..Default::default() }))
+			Candidate { who, ..Default::default() }.to_ptr()
 		})
 		.collect::<Vec<CandidatePtr<AccountId>>>();