Use enum for channel success probability

The channel success probability can be represented as a ratio, which
allows for approximating the log10.

Author: jkczyz

lightning/src/routing/scoring.rs

@@ -565,6 +565,13 @@ struct DirectedChannelLiquidity<L: Deref<Target = u64>, T: Time, U: Deref<Target
 	half_life: Duration,
 }
 
+/// The likelihood of an event occurring.
+enum Probability {
+	Zero,
+	One,
+	Ratio { numerator: u64, denominator: u64 },
+}
+
 impl<G: Deref<Target = NetworkGraph>, T: Time> ProbabilisticScorerUsingTime<G, T> {
 	/// Creates a new scorer using the given scoring parameters for sending payments from a node
 	/// through a network graph.
@@ -648,18 +655,18 @@ impl<T: Time> ChannelLiquidity<T> {
 impl<L: Deref<Target = u64>, T: Time, U: Deref<Target = T>> DirectedChannelLiquidity<L, T, U> {
 	/// Returns the success probability of routing the given HTLC `amount_msat` through the channel
 	/// in this direction.
-	fn success_probability(&self, amount_msat: u64) -> f64 {
+	fn success_probability(&self, amount_msat: u64) -> Probability {
 		let max_liquidity_msat = self.max_liquidity_msat();
 		let min_liquidity_msat = core::cmp::min(self.min_liquidity_msat(), max_liquidity_msat);
 		if amount_msat > max_liquidity_msat {
-			0.0
+			Probability::Zero
 		} else if amount_msat <= min_liquidity_msat {
-			1.0
+			Probability::One
 		} else {
 			let numerator = max_liquidity_msat + 1 - amount_msat;
 			let denominator = max_liquidity_msat + 1 - min_liquidity_msat;
-			numerator as f64 / denominator as f64
-		}.max(0.01) // Lower bound the success probability to ensure some channel is selected.
+			Probability::Ratio { numerator, denominator }
+		}
 	}
 
 	/// Returns the lower bound of the channel liquidity balance in this direction.
@@ -738,10 +745,16 @@ impl<G: Deref<Target = NetworkGraph>, T: Time> Score for ProbabilisticScorerUsin
 			.unwrap_or(&ChannelLiquidity::new())
 			.as_directed(source, target, capacity_msat, liquidity_offset_half_life)
 			.success_probability(amount_msat);
-		// NOTE: If success_probability is ever changed to return 0.0, log10 is undefined so return
-		// u64::max_value instead.
-		debug_assert!(success_probability > core::f64::EPSILON);
-		(-(success_probability.log10()) * liquidity_penalty_multiplier_msat as f64) as u64
+		let channel_penalty_msat = match success_probability {
+			Probability::Zero => u64::max_value(),
+			Probability::One => 0,
+			Probability::Ratio { numerator, denominator } => {
+				let success_probability = numerator as f64 / denominator as f64;
+				(-(success_probability.log10()) * liquidity_penalty_multiplier_msat as f64) as u64
+			}
+		};
+		// Upper bound the penalty to ensure some channel is selected.
+		channel_penalty_msat.min(2 * liquidity_penalty_multiplier_msat)
 	}
 
 	fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) {