concrete: use PositiveF64 directly in TapleafProbabilityIter

Look ma, no type conversions!

Author: apoelstra

src/policy/concrete.rs

@@ -168,12 +168,12 @@ impl error::Error for PolicyError {
 
 #[cfg(feature = "compiler")]
 struct TapleafProbabilityIter<'p, Pk: MiniscriptKey> {
-    stack: Vec<(f64, &'p Policy<Pk>)>,
+    stack: Vec<(PositiveF64, &'p Policy<Pk>)>,
 }
 
 #[cfg(feature = "compiler")]
 impl<'p, Pk: MiniscriptKey> Iterator for TapleafProbabilityIter<'p, Pk> {
-    type Item = (f64, &'p Policy<Pk>);
+    type Item = (PositiveF64, &'p Policy<Pk>);
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {
@@ -184,11 +184,11 @@ impl<'p, Pk: MiniscriptKey> Iterator for TapleafProbabilityIter<'p, Pk> {
                     let normalized_iter =
                         PositiveF64::normalized_iter(subs.iter().map(|x| x.0.into()));
                     for (ratio, (_, sub)) in normalized_iter.zip(subs.iter()).rev() {
-                        self.stack.push((top_prob * f64::from(ratio), sub));
+                        self.stack.push((top_prob * ratio, sub));
                     }
                 }
                 Policy::Thresh(ref thresh) if thresh.is_or() => {
-                    let n64 = thresh.n() as f64;
+                    let n64 = PositiveF64::n(thresh);
                     for sub in thresh.iter().rev() {
                         self.stack.push((top_prob / n64, sub));
                     }
@@ -240,7 +240,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     /// leaf-nodes to [`MAX_COMPILATION_LEAVES`].
     #[cfg(feature = "compiler")]
     fn tapleaf_probability_iter(&self) -> TapleafProbabilityIter<'_, Pk> {
-        TapleafProbabilityIter { stack: vec![(1.0, self)] }
+        TapleafProbabilityIter { stack: vec![(PositiveF64::ONE, self)] }
     }
 
     /// Extracts the internal_key from this policy tree.
@@ -249,7 +249,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
         let internal_key = self
             .tapleaf_probability_iter()
             .filter_map(|(prob, ref pol)| match pol {
-                Self::Key(pk) => Some((PositiveF64(prob), pk)),
+                Self::Key(pk) => Some((prob, pk)),
                 _ => None,
             })
             .max_by_key(|(prob, _)| *prob)
@@ -302,7 +302,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                                     continue;
                                 }
                                 let compilation = compiler::best_compilation::<Pk, Tap>(pol)?;
-                                leaf_compilations.push((PositiveF64(prob), compilation));
+                                leaf_compilations.push((prob, compilation));
                             }
                             if !leaf_compilations.is_empty() {
                                 let tap_tree = with_huffman_tree::<Pk>(leaf_compilations);

src/primitives/positive_f64.rs

@@ -1,16 +1,20 @@
 // SPDX-License-Identifier: CC0-1.0
 
 //! Positive floats ("branch probabilities" for policies)
-
 use core::iter::FusedIterator;
 use core::num::NonZeroU32;
-use core::{cmp, hash};
+use core::{cmp, hash, ops};
+
+use crate::Threshold;
 
 /// Ordered f64 for comparison.
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct PositiveF64(pub f64);
 
 impl PositiveF64 {
+    /// The constant one.
+    pub const ONE: Self = Self(1.0);
+
     /// Takes an iterator over [`PositiveF64`] and produces a new iterator where
     /// each item is divided so that they all total to 1.
     ///
@@ -28,6 +32,11 @@ impl PositiveF64 {
         let sum = iter.clone().map(|x| x.0).sum::<f64>();
         NormalizedIterator { iter, sum }
     }
+
+    /// The 'n' value of a threshold, as a [`PositiveF64`]
+    pub fn n<const MAX: usize, T>(t: &Threshold<T, MAX>) -> Self {
+        Self(t.n() as f64) // cast okay, worst case wil lose precision
+    }
 }
 
 impl Eq for PositiveF64 {}
@@ -58,6 +67,21 @@ impl From<NonZeroU32> for PositiveF64 {
     fn from(value: NonZeroU32) -> Self { Self(f64::from(u32::from(value))) }
 }
 
+impl ops::Add for PositiveF64 {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output { Self(self.0 + rhs.0) }
+}
+
+impl ops::Mul for PositiveF64 {
+    type Output = Self;
+    fn mul(self, rhs: Self) -> Self::Output { Self(self.0 * rhs.0) }
+}
+
+impl ops::Div for PositiveF64 {
+    type Output = Self;
+    fn div(self, rhs: Self) -> Self::Output { Self(self.0 / rhs.0) }
+}
+
 pub struct NormalizedIterator<I> {
     iter: I,
     /// Sum must be nonnegative, and may only be zero if `iter` is empty.