diff -r edb95d2b83cc -r d2acaaddd9af src/bisection_tree/bt.rs
--- a/src/bisection_tree/bt.rs	Sun Nov 10 09:02:57 2024 -0500
+++ b/src/bisection_tree/bt.rs	Tue Dec 31 09:12:43 2024 -0500
@@ -243,10 +243,11 @@
 
     /// Creates a new node branching structure, subdividing `domain` based on the
     /// [hint][Support::support_hint] of `support`.
-    pub(super) fn new_with<S : LocalAnalysis <F, A, N>>(
+    pub(super) fn new_with<S>(
         domain : &Cube<F,N>,
         support : &S
-    ) -> Self {
+    ) -> Self
+    where S : Support<N, RealField=F> + LocalAnalysis<A, Cube<F, N>> {
         let hint = support.bisection_hint(domain);
         let branch_at = map2(&hint, domain, |h, r| {
             h.unwrap_or_else(|| (r[0]+r[1])/F::TWO).max(r[0]).min(r[1])
@@ -321,14 +322,15 @@
     ///  * `support` is the [`Support`] that is used determine with which subcubes of `domain`
     ///     (at subdivision depth `new_leaf_depth`) the data `d` is to be associated with.
     ///
-    pub(super) fn insert<'refs, 'scope, M : Depth, S : LocalAnalysis<F, A, N>>(
+    pub(super) fn insert<'refs, 'scope, M : Depth, S>(
         &mut self,
         domain : &Cube<F,N>,
         d : D,
         new_leaf_depth : M,
         support : &S,
         task_budget : TaskBudget<'scope, 'refs>,
-    ) {
+    )
+    where S : Support<N, RealField=F> + LocalAnalysis<A, Cube<F, N>> {
         let support_hint = support.support_hint();
         self.recurse(domain, task_budget,
                      |_, subcube| support_hint.intersects(&subcube),
@@ -348,8 +350,8 @@
         domain : &Cube<F, N>
     ) -> Branches<F,D,ANew,N,P>
     where ANew : Aggregator,
-          G : SupportGenerator<F, N, Id=D>,
-          G::SupportType : LocalAnalysis<F, ANew, N> {
+          G : SupportGenerator<N, Id=D, RealField = F>,
+          G::SupportType : LocalAnalysis<ANew, Cube<F, N>> {
         let branch_at = self.branch_at;
         let subcube_iter = self.iter_subcubes(domain);
         let new_nodes = self.nodes.into_iter().zip(subcube_iter).map(|(node, subcube)| {
@@ -370,8 +372,8 @@
         generator : &G,
         domain : &Cube<F, N>,
         task_budget : TaskBudget<'scope, 'refs>,
-    ) where G : SupportGenerator<F, N, Id=D>,
-            G::SupportType : LocalAnalysis<F, A, N> {
+    ) where G : SupportGenerator<N, Id=D, RealField = F>,
+            G::SupportType : LocalAnalysis<A, Cube<F, N>> {
         self.recurse(domain, task_budget,
                      |_, _| true,
                      move |node, subcube, new_budget| node.refresh_aggregator(generator, subcube,
@@ -434,14 +436,15 @@
     /// If `self` is a [`NodeOption::Branches`], the data is passed to branches whose subcubes
     /// `support` intersects. If an [`NodeOption::Uninitialised`] node is encountered, a new leaf is
     /// created at a minimum depth of `new_leaf_depth`.
-    pub(super) fn insert<'refs, 'scope, M : Depth, S : LocalAnalysis <F, A, N>>(
+    pub(super) fn insert<'refs, 'scope, M : Depth, S>(
         &mut self,
         domain : &Cube<F,N>,
         d : D,
         new_leaf_depth : M,
         support : &S,
         task_budget : TaskBudget<'scope, 'refs>,
-    ) {
+    )
+    where S : Support<N, RealField = F> + LocalAnalysis<A, Cube<F, N>> {
         match &mut self.data {
             NodeOption::Uninitialised => {
                 // Replace uninitialised node with a leaf or a branch
@@ -493,8 +496,8 @@
         domain : &Cube<F, N>
     ) -> Node<F,D,ANew,N,P>
     where ANew : Aggregator,
-          G : SupportGenerator<F, N, Id=D>,
-          G::SupportType : LocalAnalysis<F, ANew, N> {
+          G : SupportGenerator<N, Id=D, RealField = F>,
+          G::SupportType : LocalAnalysis<ANew, Cube<F, N>> {
 
         // The mem::replace is needed due to the [`Drop`] implementation to extract self.data.
         match std::mem::replace(&mut self.data, NodeOption::Uninitialised) {
@@ -537,8 +540,8 @@
         generator : &G,
         domain : &Cube<F, N>,
         task_budget : TaskBudget<'scope, 'refs>,
-    ) where G : SupportGenerator<F, N, Id=D>,
-            G::SupportType : LocalAnalysis<F, A, N> {
+    ) where G : SupportGenerator<N, Id=D, RealField = F>,
+            G::SupportType : LocalAnalysis<A, Cube<F, N>> {
         match &mut self.data {
             NodeOption::Uninitialised => { },
             NodeOption::Leaf(v) => {
@@ -580,7 +583,7 @@
 /// Basic interface to a [`BT`] bisection tree.
 ///
 /// Further routines are provided by the [`BTSearch`][super::refine::BTSearch] trait.
-pub trait BTImpl<F : Float, const N : usize> : std::fmt::Debug + Clone + GlobalAnalysis<F, Self::Agg> {
+pub trait BTImpl<F : Float, const N : usize> : std::fmt::Debug + Clone + GlobalAnalysis<Self::Agg> {
     /// The data type stored in the tree
     type Data : 'static + Copy + Send + Sync;
     /// The depth type of the tree
@@ -595,11 +598,12 @@
     ///
     /// Every leaf node of the tree that intersects the `support` will contain a copy of
     /// `d`.
-    fn insert<S : LocalAnalysis<F, Self::Agg, N>>(
+    fn insert<S>(
         &mut self,
         d : Self::Data,
         support : &S
-    );
+    )
+    where S: Support<N, RealField=F> + LocalAnalysis<Self::Agg, Cube<F, N>>;
 
     /// Construct a new instance of the tree for a different aggregator
     ///
@@ -608,8 +612,8 @@
     fn convert_aggregator<ANew, G>(self, generator : &G)
     -> Self::Converted<ANew>
     where ANew : Aggregator,
-          G : SupportGenerator<F, N, Id=Self::Data>,
-          G::SupportType : LocalAnalysis<F, ANew, N>;
+          G : SupportGenerator< N, Id=Self::Data, RealField = F>,
+          G::SupportType : LocalAnalysis<ANew, Cube<F, N>>;
 
 
     /// Refreshes the aggregator of the three after possible changes to the support generator.
@@ -617,8 +621,8 @@
     /// The `generator` is used to convert the data of type [`Self::Data`] contained in the tree
     /// into corresponding [`Support`]s.
     fn refresh_aggregator<G>(&mut self, generator : &G)
-    where G : SupportGenerator<F, N, Id=Self::Data>,
-          G::SupportType : LocalAnalysis<F, Self::Agg, N>;
+    where G : SupportGenerator<N, Id=Self::Data, RealField = F>,
+          G::SupportType : LocalAnalysis<Self::Agg, Cube<F, N>>;
 
     /// Returns an iterator over all [`Self::Data`] items at the point `x` of the domain.
     fn iter_at(&self, x : &Loc<F,N>) -> std::slice::Iter<'_, Self::Data>;
@@ -672,11 +676,12 @@
             type Agg = A;
             type Converted<ANew> = BT<M,F,D,ANew,$n> where ANew : Aggregator;
 
-            fn insert<S: LocalAnalysis<F, A, $n>>(
+            fn insert<S>(
                 &mut self,
                 d : D,
                 support : &S
-            ) {
+            )
+            where S : Support<$n, RealField = F> + LocalAnalysis<A, Cube<F, $n>> {
                 with_task_budget(|task_budget|
                     self.topnode.insert(
                         &self.domain,
@@ -690,8 +695,8 @@
 
             fn convert_aggregator<ANew, G>(self, generator : &G) -> Self::Converted<ANew>
             where ANew : Aggregator,
-                  G : SupportGenerator<F, $n, Id=D>,
-                  G::SupportType : LocalAnalysis<F, ANew, $n> {
+                  G : SupportGenerator<$n, Id=D, RealField = F>,
+                  G::SupportType : LocalAnalysis<ANew, Cube<F, $n>> {
                 let topnode = self.topnode.convert_aggregator(generator, &self.domain);
 
                 BT {
@@ -702,8 +707,8 @@
             }
 
             fn refresh_aggregator<G>(&mut self, generator : &G)
-            where G : SupportGenerator<F, $n, Id=Self::Data>,
-                G::SupportType : LocalAnalysis<F, Self::Agg, $n> {
+            where G : SupportGenerator<$n, Id=Self::Data, RealField = F>,
+                  G::SupportType : LocalAnalysis<Self::Agg, Cube<F, $n>> {
                 with_task_budget(|task_budget|
                     self.topnode.refresh_aggregator(generator, &self.domain, task_budget)
                 )
@@ -726,7 +731,7 @@
             }
         }
 
-        impl<M,F,D,A> GlobalAnalysis<F,A> for BT<M,F,D,A,$n>
+        impl<M,F,D,A> GlobalAnalysis<A> for BT<M,F,D,A,$n>
         where M : Depth,
               F : Float,
               D : 'static + Copy + Send + Sync + std::fmt::Debug,