diff -r 495448cca603 -r 6aa955ad8122 src/bisection_tree/btfn.rs
--- a/src/bisection_tree/btfn.rs	Thu May 01 08:40:33 2025 -0500
+++ b/src/bisection_tree/btfn.rs	Thu May 01 13:06:58 2025 -0500
@@ -22,7 +22,7 @@
 /// Presentation for (mathematical) functions constructed as a sum of components functions with
 /// typically small support.
 ///
-/// The domain of the function is [`Loc`]`<F, N>`, where `F` is the type of floating point numbers,
+/// The domain of the function is [`Loc`]`<N, F>`, where `F` is the type of floating point numbers,
 /// and `N` the dimension.
 ///
 /// The `generator` lists the component functions that have to implement [`Support`].
@@ -30,7 +30,7 @@
 /// in a [bisection tree][BTImpl], when one is provided as `bt`. However `bt` may also be `()`
 /// for a [`PreBTFN`] that is only useful for vector space operations with a full [`BTFN`].
 #[derive(Clone, Debug)]
-pub struct BTFN<F: Float, G: SupportGenerator<F, N>, BT /*: BTImpl<F, N>*/, const N: usize> /*where G::SupportType : LocalAnalysis<F, A, N>*/
+pub struct BTFN<F: Float, G: SupportGenerator<N, F>, BT /*: BTImpl< N, F>*/, const N: usize> /*where G::SupportType : LocalAnalysis<F, A, N>*/
 {
     bt: BT,
     generator: Arc<G>,
@@ -39,18 +39,18 @@
 
 impl<F: Float, G, BT, const N: usize> Space for BTFN<F, G, BT, N>
 where
-    G: SupportGenerator<F, N, Id = BT::Data>,
+    G: SupportGenerator<N, F, Id = BT::Data>,
     G::SupportType: LocalAnalysis<F, BT::Agg, N>,
-    BT: BTImpl<F, N>,
+    BT: BTImpl<N, F>,
 {
     type Decomp = BasicDecomposition;
 }
 
 impl<F: Float, G, BT, const N: usize> BTFN<F, G, BT, N>
 where
-    G: SupportGenerator<F, N, Id = BT::Data>,
+    G: SupportGenerator<N, F, Id = BT::Data>,
     G::SupportType: LocalAnalysis<F, BT::Agg, N>,
-    BT: BTImpl<F, N>,
+    BT: BTImpl<N, F>,
 {
     /// Create a new BTFN from a support generator and a pre-initialised bisection tree.
     ///
@@ -92,11 +92,11 @@
     /// The top node of the created [`BT`] will have the given `domain`.
     ///
     /// See the documentation for [`BTFN`] on the role of the `generator`.
-    pub fn construct(domain: Cube<F, N>, depth: BT::Depth, generator: G) -> Self {
+    pub fn construct(domain: Cube<N, F>, depth: BT::Depth, generator: G) -> Self {
         Self::construct_arc(domain, depth, Arc::new(generator))
     }
 
-    fn construct_arc(domain: Cube<F, N>, depth: BT::Depth, generator: Arc<G>) -> Self {
+    fn construct_arc(domain: Cube<N, F>, depth: BT::Depth, generator: Arc<G>) -> Self {
         let mut bt = BT::new(domain, depth);
         for (d, support) in generator.all_data() {
             bt.insert(d, &support);
@@ -111,7 +111,7 @@
     pub fn convert_aggregator<ANew>(self) -> BTFN<F, G, BT::Converted<ANew>, N>
     where
         ANew: Aggregator,
-        G: SupportGenerator<F, N, Id = BT::Data>,
+        G: SupportGenerator<N, F, Id = BT::Data>,
         G::SupportType: LocalAnalysis<F, ANew, N>,
     {
         BTFN::new_arc(self.bt.convert_aggregator(&*self.generator), self.generator)
@@ -130,15 +130,15 @@
 
 impl<F: Float, G, BT, const N: usize> BTFN<F, G, BT, N>
 where
-    G: SupportGenerator<F, N>,
+    G: SupportGenerator<N, F>,
 {
     /// Change the [bisection tree][BTImpl] of the [`BTFN`] to a different one.
     ///
     /// This can be used to convert a [`PreBTFN`] to a full [`BTFN`], or the change
     /// the aggreagator; see also [`self.convert_aggregator`].
-    pub fn instantiate<BTNew: BTImpl<F, N, Data = G::Id>>(
+    pub fn instantiate<BTNew: BTImpl<N, F, Data = G::Id>>(
         self,
-        domain: Cube<F, N>,
+        domain: Cube<N, F>,
         depth: BTNew::Depth,
     ) -> BTFN<F, G, BTNew, N>
     where
@@ -157,7 +157,7 @@
 
 impl<F: Float, G, const N: usize> PreBTFN<F, G, N>
 where
-    G: SupportGenerator<F, N>,
+    G: SupportGenerator<N, F>,
 {
     /// Create a new [`PreBTFN`] with no bisection tree.
     pub fn new_pre(generator: G) -> Self {
@@ -171,14 +171,14 @@
 
 impl<F: Float, G, BT, const N: usize> BTFN<F, G, BT, N>
 where
-    G: SupportGenerator<F, N, Id = usize>,
+    G: SupportGenerator<N, F, Id = usize>,
     G::SupportType: LocalAnalysis<F, BT::Agg, N>,
-    BT: BTImpl<F, N, Data = usize>,
+    BT: BTImpl<N, F, Data = usize>,
 {
     /// Helper function for implementing [`std::ops::Add`].
     fn add_another<G2>(&self, g2: Arc<G2>) -> BTFN<F, BothGenerators<G, G2>, BT, N>
     where
-        G2: SupportGenerator<F, N, Id = usize>,
+        G2: SupportGenerator<N, F, Id = usize>,
         G2::SupportType: LocalAnalysis<F, BT::Agg, N>,
     {
         let mut bt = self.bt.clone();
@@ -201,9 +201,9 @@
         impl<'a, F : Float, G1, G2, BT1, BT2, const N : usize>
         std::ops::Add<BTFN<F, G2, BT2, N>> for
         $lhs
-        where BT1 : BTImpl<F, N, Data=usize>,
-              G1 : SupportGenerator<F, N, Id=usize> + $($extra_trait)?,
-              G2 : SupportGenerator<F, N, Id=usize>,
+        where BT1 : BTImpl< N, F,  Data=usize>,
+              G1 : SupportGenerator< N, F, Id=usize> + $($extra_trait)?,
+              G2 : SupportGenerator< N, F, Id=usize>,
               G1::SupportType : LocalAnalysis<F, BT1::Agg, N>,
               G2::SupportType : LocalAnalysis<F, BT1::Agg, N> {
             type Output = BTFN<F, BothGenerators<G1, G2>, BT1, N>;
@@ -216,9 +216,9 @@
         impl<'a, 'b, F : Float, G1, G2,  BT1, BT2, const N : usize>
         std::ops::Add<&'b BTFN<F, G2, BT2, N>> for
         $lhs
-        where BT1 : BTImpl<F, N, Data=usize>,
-              G1 : SupportGenerator<F, N, Id=usize> + $($extra_trait)?,
-              G2 : SupportGenerator<F, N, Id=usize>,
+        where BT1 : BTImpl< N, F,  Data=usize>,
+              G1 : SupportGenerator< N, F, Id=usize> + $($extra_trait)?,
+              G2 : SupportGenerator< N, F, Id=usize>,
               G1::SupportType : LocalAnalysis<F, BT1::Agg, N>,
               G2::SupportType : LocalAnalysis<F, BT1::Agg, N> {
 
@@ -239,9 +239,9 @@
         impl<'a, F : Float, G1, G2, BT1, BT2, const N : usize>
         std::ops::Sub<BTFN<F, G2, BT2, N>> for
         $lhs
-        where BT1 : BTImpl<F, N, Data=usize>,
-              G1 : SupportGenerator<F, N, Id=usize> + $($extra_trait)?,
-              G2 : SupportGenerator<F, N, Id=usize>,
+        where BT1 : BTImpl< N, F,  Data=usize>,
+              G1 : SupportGenerator< N, F, Id=usize> + $($extra_trait)?,
+              G2 : SupportGenerator< N, F, Id=usize>,
               G1::SupportType : LocalAnalysis<F, BT1::Agg, N>,
               G2::SupportType : LocalAnalysis<F, BT1::Agg, N> {
             type Output = BTFN<F, BothGenerators<G1, G2>, BT1, N>;
@@ -258,9 +258,9 @@
         impl<'a, 'b, F : Float, G1, G2,  BT1, BT2, const N : usize>
         std::ops::Sub<&'b BTFN<F, G2, BT2, N>> for
         $lhs
-        where BT1 : BTImpl<F, N, Data=usize>,
-              G1 : SupportGenerator<F, N, Id=usize> + $($extra_trait)?,
-              G2 : SupportGenerator<F, N, Id=usize> + Clone,
+        where BT1 : BTImpl< N, F,  Data=usize>,
+              G1 : SupportGenerator< N, F, Id=usize> + $($extra_trait)?,
+              G2 : SupportGenerator< N, F, Id=usize> + Clone,
               G1::SupportType : LocalAnalysis<F, BT1::Agg, N>,
               G2::SupportType : LocalAnalysis<F, BT1::Agg, N>,
               &'b G2 : std::ops::Neg<Output=G2> {
@@ -281,8 +281,8 @@
     ($trait:ident, $fn:ident, $trait_assign:ident, $fn_assign:ident) => {
         impl<F: Float, G, BT, const N: usize> std::ops::$trait_assign<F> for BTFN<F, G, BT, N>
         where
-            BT: BTImpl<F, N>,
-            G: SupportGenerator<F, N, Id = BT::Data>,
+            BT: BTImpl<N, F>,
+            G: SupportGenerator<N, F, Id = BT::Data>,
             G::SupportType: LocalAnalysis<F, BT::Agg, N>,
         {
             #[inline]
@@ -294,8 +294,8 @@
 
         impl<F: Float, G, BT, const N: usize> std::ops::$trait<F> for BTFN<F, G, BT, N>
         where
-            BT: BTImpl<F, N>,
-            G: SupportGenerator<F, N, Id = BT::Data>,
+            BT: BTImpl<N, F>,
+            G: SupportGenerator<N, F, Id = BT::Data>,
             G::SupportType: LocalAnalysis<F, BT::Agg, N>,
         {
             type Output = Self;
@@ -309,8 +309,8 @@
 
         impl<'a, F: Float, G, BT, const N: usize> std::ops::$trait<F> for &'a BTFN<F, G, BT, N>
         where
-            BT: BTImpl<F, N>,
-            G: SupportGenerator<F, N, Id = BT::Data>,
+            BT: BTImpl<N, F>,
+            G: SupportGenerator<N, F, Id = BT::Data>,
             G::SupportType: LocalAnalysis<F, BT::Agg, N>,
             &'a G: std::ops::$trait<F, Output = G>,
         {
@@ -331,8 +331,8 @@
         impl<G, BT, const N : usize>
         std::ops::$trait<BTFN<$f, G, BT, N>>
         for $f
-        where BT : BTImpl<$f, N>,
-              G : SupportGenerator<$f, N, Id=BT::Data>,
+        where BT : BTImpl< N, $f>,
+              G : SupportGenerator< N, $f, Id=BT::Data>,
               G::SupportType : LocalAnalysis<$f, BT::Agg, N> {
             type Output = BTFN<$f, G, BT, N>;
             #[inline]
@@ -346,8 +346,8 @@
         impl<'a, G, BT, const N : usize>
         std::ops::$trait<&'a BTFN<$f, G, BT, N>>
         for $f
-        where BT : BTImpl<$f, N>,
-              G : SupportGenerator<$f, N, Id=BT::Data> + Clone,
+        where BT : BTImpl< N, $f>,
+              G : SupportGenerator< N, $f, Id=BT::Data> + Clone,
               G::SupportType : LocalAnalysis<$f, BT::Agg, N>,
               // FIXME: This causes compiler overflow
               /*&'a G : std::ops::$trait<$f,Output=G>*/ {
@@ -371,8 +371,8 @@
     ($trait:ident, $fn:ident) => {
         impl<F: Float, G, BT, const N: usize> std::ops::$trait for BTFN<F, G, BT, N>
         where
-            BT: BTImpl<F, N>,
-            G: SupportGenerator<F, N, Id = BT::Data>,
+            BT: BTImpl<N, F>,
+            G: SupportGenerator<N, F, Id = BT::Data>,
             G::SupportType: LocalAnalysis<F, BT::Agg, N>,
         {
             type Output = Self;
@@ -387,8 +387,8 @@
         /*impl<'a, F : Float, G, BT, const N : usize>
         std::ops::$trait
         for &'a BTFN<F, G, BT, N>
-        where BT : BTImpl<F, N>,
-              G : SupportGenerator<F, N, Id=BT::Data>,
+        where BT : BTImpl< N, F>,
+              G : SupportGenerator< N, F, Id=BT::Data>,
               G::SupportType : LocalAnalysis<F, BT::Agg, N>,
               &'a G : std::ops::$trait<Output=G> {
             type Output = BTFN<F, G, BT, N>;
@@ -406,16 +406,16 @@
 // Apply, Mapping, Differentiate
 //
 
-impl<F: Float, G, BT, V, const N: usize> Mapping<Loc<F, N>> for BTFN<F, G, BT, N>
+impl<F: Float, G, BT, V, const N: usize> Mapping<Loc<N, F>> for BTFN<F, G, BT, N>
 where
-    BT: BTImpl<F, N>,
-    G: SupportGenerator<F, N, Id = BT::Data>,
-    G::SupportType: LocalAnalysis<F, BT::Agg, N> + Mapping<Loc<F, N>, Codomain = V>,
+    BT: BTImpl<N, F>,
+    G: SupportGenerator<N, F, Id = BT::Data>,
+    G::SupportType: LocalAnalysis<F, BT::Agg, N> + Mapping<Loc<N, F>, Codomain = V>,
     V: Sum + Space,
 {
     type Codomain = V;
 
-    fn apply<I: Instance<Loc<F, N>>>(&self, x: I) -> Self::Codomain {
+    fn apply<I: Instance<Loc<N, F>>>(&self, x: I) -> Self::Codomain {
         let xc = x.cow();
         self.bt
             .iter_at(&*xc)
@@ -424,17 +424,17 @@
     }
 }
 
-impl<F: Float, G, BT, V, const N: usize> DifferentiableImpl<Loc<F, N>> for BTFN<F, G, BT, N>
+impl<F: Float, G, BT, V, const N: usize> DifferentiableImpl<Loc<N, F>> for BTFN<F, G, BT, N>
 where
-    BT: BTImpl<F, N>,
-    G: SupportGenerator<F, N, Id = BT::Data>,
+    BT: BTImpl<N, F>,
+    G: SupportGenerator<N, F, Id = BT::Data>,
     G::SupportType:
-        LocalAnalysis<F, BT::Agg, N> + DifferentiableMapping<Loc<F, N>, DerivativeDomain = V>,
+        LocalAnalysis<F, BT::Agg, N> + DifferentiableMapping<Loc<N, F>, DerivativeDomain = V>,
     V: Sum + Space,
 {
     type Derivative = V;
 
-    fn differential_impl<I: Instance<Loc<F, N>>>(&self, x: I) -> Self::Derivative {
+    fn differential_impl<I: Instance<Loc<N, F>>>(&self, x: I) -> Self::Derivative {
         let xc = x.cow();
         self.bt
             .iter_at(&*xc)
@@ -449,8 +449,8 @@
 
 impl<F: Float, G, BT, const N: usize> GlobalAnalysis<F, BT::Agg> for BTFN<F, G, BT, N>
 where
-    BT: BTImpl<F, N>,
-    G: SupportGenerator<F, N, Id = BT::Data>,
+    BT: BTImpl<N, F>,
+    G: SupportGenerator<N, F, Id = BT::Data>,
     G::SupportType: LocalAnalysis<F, BT::Agg, N>,
 {
     #[inline]
@@ -467,8 +467,8 @@
 /*
 impl<'b, X, F : Float, G, BT, const N : usize> Apply<&'b X, F>
 for BTFN<F, G, BT, N>
-where BT : BTImpl<F, N>,
-      G : SupportGenerator<F, N, Id=BT::Data>,
+where BT : BTImpl< N, F>,
+      G : SupportGenerator< N, F, Id=BT::Data>,
       G::SupportType : LocalAnalysis<F, BT::Agg, N>,
       X : for<'a> Apply<&'a BTFN<F, G, BT, N>, F> {
 
@@ -480,8 +480,8 @@
 
 impl<X, F : Float, G, BT, const N : usize> Apply<X, F>
 for BTFN<F, G, BT, N>
-where BT : BTImpl<F, N>,
-      G : SupportGenerator<F, N, Id=BT::Data>,
+where BT : BTImpl< N, F>,
+      G : SupportGenerator< N, F, Id=BT::Data>,
       G::SupportType : LocalAnalysis<F, BT::Agg, N>,
       X : for<'a> Apply<&'a BTFN<F, G, BT, N>, F> {
 
@@ -493,8 +493,8 @@
 
 impl<X, F : Float, G, BT, const N : usize> Linear<X>
 for BTFN<F, G, BT, N>
-where BT : BTImpl<F, N>,
-      G : SupportGenerator<F, N, Id=BT::Data>,
+where BT : BTImpl< N, F>,
+      G : SupportGenerator< N, F, Id=BT::Data>,
       G::SupportType : LocalAnalysis<F, BT::Agg, N>,
       X : for<'a> Apply<&'a BTFN<F, G, BT, N>, F> {
     type Codomain = F;
@@ -512,16 +512,16 @@
     fn p2_minimise<G: Fn(&U) -> F>(&self, g: G) -> (U, F);
 }
 
-impl<F: Float> P2Minimise<Loc<F, 1>, F> for Cube<F, 1> {
-    fn p2_minimise<G: Fn(&Loc<F, 1>) -> F>(&self, g: G) -> (Loc<F, 1>, F) {
+impl<F: Float> P2Minimise<Loc<1, F>, F> for Cube<1, F> {
+    fn p2_minimise<G: Fn(&Loc<1, F>) -> F>(&self, g: G) -> (Loc<1, F>, F) {
         let interval = Simplex(self.corners());
         interval.p2_model(&g).minimise(&interval)
     }
 }
 
 #[replace_float_literals(F::cast_from(literal))]
-impl<F: Float> P2Minimise<Loc<F, 2>, F> for Cube<F, 2> {
-    fn p2_minimise<G: Fn(&Loc<F, 2>) -> F>(&self, g: G) -> (Loc<F, 2>, F) {
+impl<F: Float> P2Minimise<Loc<2, F>, F> for Cube<2, F> {
+    fn p2_minimise<G: Fn(&Loc<2, F>) -> F>(&self, g: G) -> (Loc<2, F>, F) {
         if false {
             // Split into two triangle (simplex) with separate P2 model in each.
             // The six nodes of each triangle are the corners and the edges.
@@ -606,17 +606,17 @@
 
 impl<F: Float, G, const N: usize> Refiner<F, Bounds<F>, G, N> for P2Refiner<F, RefineMax>
 where
-    Cube<F, N>: P2Minimise<Loc<F, N>, F>,
-    G: SupportGenerator<F, N>,
-    G::SupportType: Mapping<Loc<F, N>, Codomain = F> + LocalAnalysis<F, Bounds<F>, N>,
+    Cube<N, F>: P2Minimise<Loc<N, F>, F>,
+    G: SupportGenerator<N, F>,
+    G::SupportType: Mapping<Loc<N, F>, Codomain = F> + LocalAnalysis<F, Bounds<F>, N>,
 {
-    type Result = Option<(Loc<F, N>, F)>;
+    type Result = Option<(Loc<N, F>, F)>;
     type Sorting = UpperBoundSorting<F>;
 
     fn refine(
         &self,
         aggregator: &Bounds<F>,
-        cube: &Cube<F, N>,
+        cube: &Cube<N, F>,
         data: &[G::Id],
         generator: &G,
         step: usize,
@@ -630,7 +630,7 @@
         }
 
         // g gives the negative of the value of the function presented by `data` and `generator`.
-        let g = move |x: &Loc<F, N>| {
+        let g = move |x: &Loc<N, F>| {
             let f = move |&d| generator.support_for(d).apply(x);
             -data.iter().map(f).sum::<F>()
         };
@@ -669,17 +669,17 @@
 
 impl<F: Float, G, const N: usize> Refiner<F, Bounds<F>, G, N> for P2Refiner<F, RefineMin>
 where
-    Cube<F, N>: P2Minimise<Loc<F, N>, F>,
-    G: SupportGenerator<F, N>,
-    G::SupportType: Mapping<Loc<F, N>, Codomain = F> + LocalAnalysis<F, Bounds<F>, N>,
+    Cube<N, F>: P2Minimise<Loc<N, F>, F>,
+    G: SupportGenerator<N, F>,
+    G::SupportType: Mapping<Loc<N, F>, Codomain = F> + LocalAnalysis<F, Bounds<F>, N>,
 {
-    type Result = Option<(Loc<F, N>, F)>;
+    type Result = Option<(Loc<N, F>, F)>;
     type Sorting = LowerBoundSorting<F>;
 
     fn refine(
         &self,
         aggregator: &Bounds<F>,
-        cube: &Cube<F, N>,
+        cube: &Cube<N, F>,
         data: &[G::Id],
         generator: &G,
         step: usize,
@@ -693,7 +693,7 @@
         }
 
         // g gives the value of the function presented by `data` and `generator`.
-        let g = move |x: &Loc<F, N>| {
+        let g = move |x: &Loc<N, F>| {
             let f = move |&d| generator.support_for(d).apply(x);
             data.iter().map(f).sum::<F>()
         };
@@ -755,7 +755,7 @@
 
 impl<F: Float, G, const N: usize> Refiner<F, Bounds<F>, G, N> for BoundRefiner<F, RefineMax>
 where
-    G: SupportGenerator<F, N>,
+    G: SupportGenerator<N, F>,
 {
     type Result = bool;
     type Sorting = UpperBoundSorting<F>;
@@ -763,7 +763,7 @@
     fn refine(
         &self,
         aggregator: &Bounds<F>,
-        _cube: &Cube<F, N>,
+        _cube: &Cube<N, F>,
         _data: &[G::Id],
         _generator: &G,
         step: usize,
@@ -790,7 +790,7 @@
 
 impl<F: Float, G, const N: usize> Refiner<F, Bounds<F>, G, N> for BoundRefiner<F, RefineMin>
 where
-    G: SupportGenerator<F, N>,
+    G: SupportGenerator<N, F>,
 {
     type Result = bool;
     type Sorting = UpperBoundSorting<F>;
@@ -798,7 +798,7 @@
     fn refine(
         &self,
         aggregator: &Bounds<F>,
-        _cube: &Cube<F, N>,
+        _cube: &Cube<N, F>,
         _data: &[G::Id],
         _generator: &G,
         step: usize,
@@ -838,14 +838,14 @@
 // there should be a result, or new nodes above the `glb` inserted into the queue. Then the waiting
 // threads can also continue processing. If, however, numerical inaccuracy destroyes the `glb`,
 // the queue may run out, and we get “Refiner failure”.
-impl<F: Float, G, BT, const N: usize> MinMaxMapping<F, N> for BTFN<F, G, BT, N>
+impl<F: Float, G, BT, const N: usize> MinMaxMapping<N, F> for BTFN<F, G, BT, N>
 where
-    BT: BTSearch<F, N, Agg = Bounds<F>>,
-    G: SupportGenerator<F, N, Id = BT::Data>,
-    G::SupportType: Mapping<Loc<F, N>, Codomain = F> + LocalAnalysis<F, Bounds<F>, N>,
-    Cube<F, N>: P2Minimise<Loc<F, N>, F>,
+    BT: BTSearch<N, F, Agg = Bounds<F>>,
+    G: SupportGenerator<N, F, Id = BT::Data>,
+    G::SupportType: Mapping<Loc<N, F>, Codomain = F> + LocalAnalysis<F, Bounds<F>, N>,
+    Cube<N, F>: P2Minimise<Loc<N, F>, F>,
 {
-    fn maximise(&mut self, tolerance: F, max_steps: usize) -> (Loc<F, N>, F) {
+    fn maximise(&mut self, tolerance: F, max_steps: usize) -> (Loc<N, F>, F) {
         let refiner = P2Refiner {
             tolerance,
             max_steps,
@@ -863,7 +863,7 @@
         bound: F,
         tolerance: F,
         max_steps: usize,
-    ) -> Option<(Loc<F, N>, F)> {
+    ) -> Option<(Loc<N, F>, F)> {
         let refiner = P2Refiner {
             tolerance,
             max_steps,
@@ -875,7 +875,7 @@
             .expect("Refiner failure.")
     }
 
-    fn minimise(&mut self, tolerance: F, max_steps: usize) -> (Loc<F, N>, F) {
+    fn minimise(&mut self, tolerance: F, max_steps: usize) -> (Loc<N, F>, F) {
         let refiner = P2Refiner {
             tolerance,
             max_steps,
@@ -893,7 +893,7 @@
         bound: F,
         tolerance: F,
         max_steps: usize,
-    ) -> Option<(Loc<F, N>, F)> {
+    ) -> Option<(Loc<N, F>, F)> {
         let refiner = P2Refiner {
             tolerance,
             max_steps,