diff -r edb95d2b83cc -r d2acaaddd9af src/bisection_tree/btfn.rs
--- a/src/bisection_tree/btfn.rs	Sun Nov 10 09:02:57 2024 -0500
+++ b/src/bisection_tree/btfn.rs	Tue Dec 31 09:12:43 2024 -0500
@@ -1,9 +1,8 @@
 
 use numeric_literals::replace_float_literals;
 use std::iter::Sum;
-use std::marker::PhantomData;
 use std::sync::Arc;
-use crate::types::Float;
+use crate::types::{Float, HasScalarField, HasRealField};
 use crate::mapping::{Apply, Mapping, Differentiable};
 //use crate::linops::{Apply, Linear};
 use crate::sets::Set;
@@ -29,21 +28,23 @@
 /// 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>,
+    G : SupportGenerator<N>,
     BT /*: BTImpl<F, N>*/,
     const N : usize
-> /*where G::SupportType : LocalAnalysis<F, A, N>*/ {
+> {
     bt : BT,
     generator : Arc<G>,
-    _phantoms : PhantomData<F>,
+}
+
+impl<G : SupportGenerator<N>, BT, const N : usize> HasScalarField for BTFN<G, BT, N> {
+    type Field = G::Field;
 }
 
 impl<F : Float, G, BT, const N : usize>
-BTFN<F, G, BT, N>
-where G : SupportGenerator<F, N, Id=BT::Data>,
-      G::SupportType : LocalAnalysis<F, BT::Agg, N>,
-      BT : BTImpl<F, N> {
+BTFN<G, BT, N>
+where G : SupportGenerator<N, RealField = F>,
+      G::SupportType : LocalAnalysis<BT::Agg, Cube<F, N>>,
+      BT : BTImpl<F, N, Data=G::Id> {
 
     /// Create a new BTFN from a support generator and a pre-initialised bisection tree.
     ///
@@ -60,7 +61,6 @@
         BTFN {
             bt : bt,
             generator : generator,
-            _phantoms : std::marker::PhantomData,
         }
     }
 
@@ -85,11 +85,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<G::Field, N>, 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<G::Field, N>, 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);
@@ -101,10 +101,10 @@
     ///
     /// This will construct a [`BTFN`] with the same components and generator as the (consumed)
     /// `self`, but a new `BT` with [`Aggregator`]s of type `ANew`.
-    pub fn convert_aggregator<ANew>(self) -> BTFN<F, G, BT::Converted<ANew>, N>
+    pub fn convert_aggregator<ANew>(self) -> BTFN<G, BT::Converted<ANew>, N>
     where ANew : Aggregator,
-          G : SupportGenerator<F, N, Id=BT::Data>,
-          G::SupportType : LocalAnalysis<F, ANew, N> {
+          G : SupportGenerator<N>,
+          G::SupportType : LocalAnalysis<ANew, Cube<G::RealField, N>> {
         BTFN::new_arc(self.bt.convert_aggregator(&*self.generator), self.generator)
     }
 
@@ -121,16 +121,16 @@
 }
 
 impl<F : Float, G, BT, const N : usize>
-BTFN<F, G, BT, N>
-where G : SupportGenerator<F, N> {
+BTFN<G, BT, N>
+where G : SupportGenerator<N, RealField = 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>,
-    > (self, domain : Cube<F, N>, depth : BTNew::Depth) -> BTFN<F, G, BTNew, N>
-    where G::SupportType : LocalAnalysis<F, BTNew::Agg, N>  {
+    > (self, domain : Cube<F, N>, depth : BTNew::Depth) -> BTFN<G, BTNew, N>
+    where G::SupportType : LocalAnalysis<BTNew::Agg, Cube<F, N>>  {
         BTFN::construct_arc(domain, depth, self.generator)
     }
 }
@@ -140,30 +140,29 @@
 /// Most BTFN methods are not available, but if a BTFN is going to be summed with another
 /// before other use, it will be more efficient to not construct an unnecessary bisection tree
 /// that would be shortly dropped.
-pub type PreBTFN<F, G, const N : usize> = BTFN<F, G, (), N>;
+pub type PreBTFN<G, const N : usize> = BTFN<G, (), N>;
 
-impl<F : Float, G, const N : usize> PreBTFN<F, G, N> where G : SupportGenerator<F, N> {
+impl<G, const N : usize> PreBTFN<G, N> where G : SupportGenerator<N> {
 
     /// Create a new [`PreBTFN`] with no bisection tree.
     pub fn new_pre(generator : G) -> Self {
         BTFN {
             bt : (),
             generator : Arc::new(generator),
-            _phantoms : std::marker::PhantomData,
         }
     }
 }
 
 impl<F : Float, G, BT, const N : usize>
-BTFN<F, G, BT, N>
-where G : SupportGenerator<F, N, Id=usize>,
-      G::SupportType : LocalAnalysis<F, BT::Agg, N>,
+BTFN<G, BT, N>
+where G : SupportGenerator<N, Id=usize, RealField = F>,
+      G::SupportType : LocalAnalysis<BT::Agg, Cube<F, N>>,
       BT : BTImpl<F, N, 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::SupportType : LocalAnalysis<F, BT::Agg, N> {
+    fn add_another<G2>(&self, g2 : Arc<G2>) -> BTFN<BothGenerators<G, G2>, BT, N>
+    where G2 : SupportGenerator<N, Id=usize, RealField = F>,
+          G2::SupportType : LocalAnalysis<BT::Agg, Cube<F, N>> {
 
         let mut bt = self.bt.clone();
         let both = BothGenerators(Arc::clone(&self.generator), g2);
@@ -175,7 +174,6 @@
         BTFN {
             bt : bt,
             generator : Arc::new(both),
-            _phantoms : std::marker::PhantomData,
         }
     }
 }
@@ -183,54 +181,54 @@
 macro_rules! make_btfn_add {
     ($lhs:ty, $preprocess:path, $($extra_trait:ident)?) => {
         impl<'a, F : Float, G1, G2, BT1, BT2, const N : usize>
-        std::ops::Add<BTFN<F, G2, BT2, N>> for
+        std::ops::Add<BTFN<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>,
-              G1::SupportType : LocalAnalysis<F, BT1::Agg, N>,
-              G2::SupportType : LocalAnalysis<F, BT1::Agg, N> {
-            type Output = BTFN<F, BothGenerators<G1, G2>, BT1, N>;
+              G1 : SupportGenerator<N, Id=usize, RealField = F> + $($extra_trait)?,
+              G2 : SupportGenerator<N, Id=usize, RealField = F>,
+              G1::SupportType : LocalAnalysis<BT1::Agg, Cube<F, N>>,
+              G2::SupportType : LocalAnalysis<BT1::Agg, Cube<F, N>> {
+            type Output = BTFN<BothGenerators<G1, G2>, BT1, N>;
             #[inline]
-            fn add(self, other : BTFN<F, G2, BT2, N>) -> Self::Output {
+            fn add(self, other : BTFN<G2, BT2, N>) -> Self::Output {
                 $preprocess(self).add_another(other.generator)
             }
         }
 
         impl<'a, 'b, F : Float, G1, G2,  BT1, BT2, const N : usize>
-        std::ops::Add<&'b BTFN<F, G2, BT2, N>> for
+        std::ops::Add<&'b BTFN<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>,
-              G1::SupportType : LocalAnalysis<F, BT1::Agg, N>,
-              G2::SupportType : LocalAnalysis<F, BT1::Agg, N> {
+              G1 : SupportGenerator<N, Id=usize, RealField = F> + $($extra_trait)?,
+              G2 : SupportGenerator<N, Id=usize, RealField = F>,
+              G1::SupportType : LocalAnalysis<BT1::Agg, Cube<F, N>>,
+              G2::SupportType : LocalAnalysis<BT1::Agg, Cube<F, N>> {
 
-            type Output = BTFN<F, BothGenerators<G1, G2>, BT1, N>;
+            type Output = BTFN<BothGenerators<G1, G2>, BT1, N>;
             #[inline]
-            fn add(self, other : &'b BTFN<F, G2, BT2, N>) -> Self::Output {
+            fn add(self, other : &'b BTFN<G2, BT2, N>) -> Self::Output {
                 $preprocess(self).add_another(other.generator.clone())
             }
         }
     }
 }
 
-make_btfn_add!(BTFN<F, G1, BT1, N>, std::convert::identity, );
-make_btfn_add!(&'a BTFN<F, G1, BT1, N>, Clone::clone, );
+make_btfn_add!(BTFN<G1, BT1, N>, std::convert::identity, );
+make_btfn_add!(&'a BTFN<G1, BT1, N>, Clone::clone, );
 
 macro_rules! make_btfn_sub {
     ($lhs:ty, $preprocess:path, $($extra_trait:ident)?) => {
         impl<'a, F : Float, G1, G2, BT1, BT2, const N : usize>
-        std::ops::Sub<BTFN<F, G2, BT2, N>> for
+        std::ops::Sub<BTFN<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>,
-              G1::SupportType : LocalAnalysis<F, BT1::Agg, N>,
-              G2::SupportType : LocalAnalysis<F, BT1::Agg, N> {
-            type Output = BTFN<F, BothGenerators<G1, G2>, BT1, N>;
+              G1 : SupportGenerator<N, Id=usize, RealField = F> + $($extra_trait)?,
+              G2 : SupportGenerator<N, Id=usize, RealField = F>,
+              G1::SupportType : LocalAnalysis<BT1::Agg, Cube<F, N>>,
+              G2::SupportType : LocalAnalysis<BT1::Agg, Cube<F, N>> {
+            type Output = BTFN<BothGenerators<G1, G2>, BT1, N>;
             #[inline]
-            fn sub(self, other : BTFN<F, G2, BT2, N>) -> Self::Output {
+            fn sub(self, other : BTFN<G2, BT2, N>) -> Self::Output {
                 $preprocess(self).add_another(Arc::new(
                     Arc::try_unwrap(other.generator)
                         .unwrap_or_else(|arc| (*arc).clone())
@@ -240,35 +238,35 @@
         }
 
         impl<'a, 'b, F : Float, G1, G2,  BT1, BT2, const N : usize>
-        std::ops::Sub<&'b BTFN<F, G2, BT2, N>> for
+        std::ops::Sub<&'b BTFN<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,
-              G1::SupportType : LocalAnalysis<F, BT1::Agg, N>,
-              G2::SupportType : LocalAnalysis<F, BT1::Agg, N>,
+              G1 : SupportGenerator<N, Id=usize, RealField = F> + $($extra_trait)?,
+              G2 : SupportGenerator<N, Id=usize, RealField = F> + Clone,
+              G1::SupportType : LocalAnalysis<BT1::Agg, Cube<F, N>>,
+              G2::SupportType : LocalAnalysis<BT1::Agg, Cube<F, N>>,
               &'b G2 : std::ops::Neg<Output=G2> {
 
-            type Output = BTFN<F, BothGenerators<G1, G2>, BT1, N>;
+            type Output = BTFN<BothGenerators<G1, G2>, BT1, N>;
             #[inline]
-            fn sub(self, other : &'b BTFN<F, G2, BT2, N>) -> Self::Output {
+            fn sub(self, other : &'b BTFN<G2, BT2, N>) -> Self::Output {
                 $preprocess(self).add_another(Arc::new((*other.generator).clone().neg()))
             }
         }
     }
 }
 
-make_btfn_sub!(BTFN<F, G1, BT1, N>, std::convert::identity, );
-make_btfn_sub!(&'a BTFN<F, G1, BT1, N>, std::convert::identity, );
+make_btfn_sub!(BTFN<G1, BT1, N>, std::convert::identity, );
+make_btfn_sub!(&'a BTFN<G1, BT1, N>, std::convert::identity, );
 
 macro_rules! make_btfn_scalarop_rhs {
     ($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>
+        for BTFN<G, BT, N>
         where BT : BTImpl<F, N>,
-              G : SupportGenerator<F, N, Id=BT::Data>,
-              G::SupportType : LocalAnalysis<F, BT::Agg, N> {
+              G : SupportGenerator<N, Id=BT::Data, RealField = F>,
+              G::SupportType : LocalAnalysis<BT::Agg, Cube<F, N>> {
             #[inline]
             fn $fn_assign(&mut self, t : F) {
                 Arc::make_mut(&mut self.generator).$fn_assign(t);
@@ -278,10 +276,10 @@
 
         impl<F : Float, G, BT, const N : usize>
         std::ops::$trait<F>
-        for BTFN<F, G, BT, N>
+        for BTFN<G, BT, N>
         where BT : BTImpl<F, N>,
-              G : SupportGenerator<F, N, Id=BT::Data>,
-              G::SupportType : LocalAnalysis<F, BT::Agg, N> {
+              G : SupportGenerator<N, Id=BT::Data, RealField = F>,
+              G::SupportType : LocalAnalysis<BT::Agg, Cube<F, N>> {
             type Output = Self;
             #[inline]
             fn $fn(mut self, t : F) -> Self::Output {
@@ -293,12 +291,12 @@
 
         impl<'a, F : Float, G, BT, const N : usize>
         std::ops::$trait<F>
-        for &'a BTFN<F, G, BT, N>
+        for &'a BTFN<G, BT, N>
         where BT : BTImpl<F, N>,
-              G : SupportGenerator<F, N, Id=BT::Data>,
-              G::SupportType : LocalAnalysis<F, BT::Agg, N>,
+              G : SupportGenerator<N, Id=BT::Data, RealField = F>,
+              G::SupportType : LocalAnalysis<BT::Agg, Cube<F, N>>,
               &'a G : std::ops::$trait<F,Output=G> {
-            type Output = BTFN<F, G, BT, N>;
+            type Output = BTFN<G, BT, N>;
             #[inline]
             fn $fn(self, t : F) -> Self::Output {
                 self.new_generator(self.generator.$fn(t))
@@ -313,14 +311,14 @@
 macro_rules! make_btfn_scalarop_lhs {
     ($trait:ident, $fn:ident, $fn_assign:ident, $($f:ident)+) => { $(
         impl<G, BT, const N : usize>
-        std::ops::$trait<BTFN<$f, G, BT, N>>
+        std::ops::$trait<BTFN<G, BT, N>>
         for $f
         where BT : BTImpl<$f, N>,
-              G : SupportGenerator<$f, N, Id=BT::Data>,
-              G::SupportType : LocalAnalysis<$f, BT::Agg, N> {
-            type Output = BTFN<$f, G, BT, N>;
+              G : SupportGenerator<N, Id=BT::Data, RealField = $f>,
+              G::SupportType : LocalAnalysis<BT::Agg, Cube<$f, N>> {
+            type Output = BTFN<G, BT, N>;
             #[inline]
-            fn $fn(self, mut a : BTFN<$f, G, BT, N>) -> Self::Output {
+            fn $fn(self, mut a : BTFN<G, BT, N>) -> Self::Output {
                 Arc::make_mut(&mut a.generator).$fn_assign(self);
                 a.refresh_aggregator();
                 a
@@ -328,16 +326,16 @@
         }
 
         impl<'a, G, BT, const N : usize>
-        std::ops::$trait<&'a BTFN<$f, G, BT, N>>
+        std::ops::$trait<&'a BTFN<G, BT, N>>
         for $f
         where BT : BTImpl<$f, N>,
-              G : SupportGenerator<$f, N, Id=BT::Data> + Clone,
-              G::SupportType : LocalAnalysis<$f, BT::Agg, N>,
+              G : SupportGenerator<N, Id=BT::Data, RealField = $f> + Clone,
+              G::SupportType : LocalAnalysis<BT::Agg, Cube<$f, N>>,
               // FIXME: This causes compiler overflow
               /*&'a G : std::ops::$trait<$f,Output=G>*/ {
-            type Output = BTFN<$f, G, BT, N>;
+            type Output = BTFN<G, BT, N>;
             #[inline]
-            fn $fn(self, a : &'a BTFN<$f, G, BT, N>) -> Self::Output {
+            fn $fn(self, a : &'a BTFN<G, BT, N>) -> Self::Output {
                 let mut tmp = (*a.generator).clone();
                 tmp.$fn_assign(self);
                 a.new_generator(tmp)
@@ -355,10 +353,10 @@
     ($trait:ident, $fn:ident) => {
         impl<F : Float, G, BT, const N : usize>
         std::ops::$trait
-        for BTFN<F, G, BT, N>
+        for BTFN<G, BT, N>
         where BT : BTImpl<F, N>,
-              G : SupportGenerator<F, N, Id=BT::Data>,
-              G::SupportType : LocalAnalysis<F, BT::Agg, N> {
+              G : SupportGenerator<N, Id=BT::Data, RealField = F>,
+              G::SupportType : LocalAnalysis<BT::Agg, Cube<F, N>> {
             type Output = Self;
             #[inline]
             fn $fn(mut self) -> Self::Output {
@@ -391,10 +389,11 @@
 //
 
 impl<'a, F : Float, G, BT, V, const N : usize> Apply<&'a Loc<F, N>>
-for BTFN<F, G, BT, N>
+for BTFN<G, BT, N>
 where BT : BTImpl<F, N>,
-      G : SupportGenerator<F, N, Id=BT::Data>,
-      G::SupportType : LocalAnalysis<F, BT::Agg, N> + Apply<&'a Loc<F, N>, Output = V>,
+      G : SupportGenerator<N, Id=BT::Data, RealField = F>,
+      G::SupportType : LocalAnalysis<BT::Agg, Cube<F, N>>
+                       + Apply<&'a Loc<F, N>, Output = V>,
       V : Sum {
 
     type Output = V;
@@ -406,10 +405,11 @@
 }
 
 impl<F : Float, G, BT, V, const N : usize> Apply<Loc<F, N>>
-for BTFN<F, G, BT, N>
+for BTFN<G, BT, N>
 where BT : BTImpl<F, N>,
-      G : SupportGenerator<F, N, Id=BT::Data>,
-      G::SupportType : LocalAnalysis<F, BT::Agg, N> + Apply<Loc<F, N>, Output = V>,
+      G : SupportGenerator<N, Id=BT::Data, RealField = F>,
+      G::SupportType : LocalAnalysis<BT::Agg, Cube<F, N>>
+                       + Apply<Loc<F, N>, Output = V>,
       V : Sum {
 
     type Output = V;
@@ -420,11 +420,13 @@
     }
 }
 
-impl<'a, F : Float, G, BT, V, const N : usize> Differentiable<&'a Loc<F, N>>
-for BTFN<F, G, BT, N>
+impl<'a, F : Float, G, BT, V : HasRealField<RealField=F>, const N : usize>
+Differentiable<&'a Loc<F, N>>
+for BTFN<G, BT, N>
 where BT : BTImpl<F, N>,
-      G : SupportGenerator<F, N, Id=BT::Data>,
-      G::SupportType : LocalAnalysis<F, BT::Agg, N> + Differentiable<&'a Loc<F, N>, Derivative = V>,
+      G : SupportGenerator<N, Id=BT::Data, RealField = F>,
+      G::SupportType : LocalAnalysis<BT::Agg, Cube<F, N>>
+                       + Differentiable<&'a Loc<F, N>, Derivative = V>,
       V : Sum {
 
     type Derivative = V;
@@ -437,11 +439,12 @@
 }
 
 impl<F : Float, G, BT, V, const N : usize> Differentiable<Loc<F, N>>
-for BTFN<F, G, BT, N>
+for BTFN<G, BT, N>
 where BT : BTImpl<F, N>,
-      G : SupportGenerator<F, N, Id=BT::Data>,
-      G::SupportType : LocalAnalysis<F, BT::Agg, N> + Differentiable<Loc<F, N>, Derivative = V>,
-      V : Sum {
+      G : SupportGenerator<N, Id=BT::Data, RealField = F>,
+      G::SupportType : LocalAnalysis<BT::Agg, Cube<F, N>>
+                       + Differentiable<Loc<F, N>, Derivative = V>,
+      V : Sum + HasRealField<RealField=F> {
 
     type Derivative = V;
 
@@ -456,11 +459,11 @@
 // GlobalAnalysis
 //
 
-impl<F : Float, G, BT, const N : usize> GlobalAnalysis<F, BT::Agg>
-for BTFN<F, G, BT, N>
+impl<F : Float, G, BT, const N : usize> GlobalAnalysis<BT::Agg>
+for BTFN<G, BT, N>
 where BT : BTImpl<F, N>,
-      G : SupportGenerator<F, N, Id=BT::Data>,
-      G::SupportType : LocalAnalysis<F, BT::Agg, N> {
+      G : SupportGenerator<N, Id=BT::Data, RealField = F>,
+      G::SupportType : LocalAnalysis<BT::Agg, Cube<F, N>> {
 
     #[inline]
     fn global_analysis(&self) -> BT::Agg {
@@ -617,12 +620,12 @@
     how : T,
 }
 
-impl<F : Float, G, const N : usize> Refiner<F, Bounds<F>, G, N>
+impl<F : Float, G, const N : usize> Refiner<Bounds<F>, G, N>
 for P2Refiner<F, RefineMax>
 where Cube<F, N> : P2Minimise<Loc<F, N>, F>,
-      G : SupportGenerator<F, N>,
+      G : SupportGenerator<N, RealField = F>,
       G::SupportType : Mapping<Loc<F, N>, Codomain=F>
-                       + LocalAnalysis<F, Bounds<F>, N> {
+                       + LocalAnalysis<Bounds<F>, Cube<F, N>> {
     type Result = Option<(Loc<F, N>, F)>;
     type Sorting = UpperBoundSorting<F>;
 
@@ -674,12 +677,12 @@
 }
 
 
-impl<F : Float, G, const N : usize> Refiner<F, Bounds<F>, G, N>
+impl<F : Float, G, const N : usize> Refiner<Bounds<F>, G, N>
 for P2Refiner<F, RefineMin>
 where Cube<F, N> : P2Minimise<Loc<F, N>, F>,
-      G : SupportGenerator<F, N>,
+      G : SupportGenerator<N, RealField = F>,
       G::SupportType : Mapping<Loc<F, N>, Codomain=F>
-                       + LocalAnalysis<F, Bounds<F>, N> {
+                       + LocalAnalysis<Bounds<F>, Cube<F, N>> {
     type Result = Option<(Loc<F, N>, F)>;
     type Sorting = LowerBoundSorting<F>;
 
@@ -754,9 +757,9 @@
     how : T,
 }
 
-impl<F : Float, G, const N : usize> Refiner<F, Bounds<F>, G, N>
+impl<F : Float, G, const N : usize> Refiner<Bounds<F>, G, N>
 for BoundRefiner<F, RefineMax>
-where G : SupportGenerator<F, N> {
+where G : SupportGenerator<N, RealField = F> {
     type Result = bool;
     type Sorting = UpperBoundSorting<F>;
 
@@ -788,9 +791,9 @@
     }
 }
 
-impl<F : Float, G, const N : usize> Refiner<F, Bounds<F>, G, N>
+impl<F : Float, G, const N : usize> Refiner<Bounds<F>, G, N>
 for BoundRefiner<F, RefineMin>
-where G : SupportGenerator<F, N> {
+where G : SupportGenerator<N, RealField = F> {
     type Result = bool;
     type Sorting = UpperBoundSorting<F>;
 
@@ -837,11 +840,11 @@
 // 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> BTFN<F, G, BT, N>
+impl<F : Float, G, BT, const N : usize> BTFN<G, BT, N>
 where BT : BTSearch<F, N, Agg=Bounds<F>>,
-      G : SupportGenerator<F, N, Id=BT::Data>,
+      G : SupportGenerator<N, Id=BT::Data, RealField = F>,
       G::SupportType : Mapping<Loc<F, N>,Codomain=F>
-                       + LocalAnalysis<F, Bounds<F>, N>,
+                       + LocalAnalysis<Bounds<F>, Cube<F, N>>,
       Cube<F, N> : P2Minimise<Loc<F, N>, F> {
 
     /// Maximise the `BTFN` within stated value `tolerance`.