diff -r 495448cca603 -r 6aa955ad8122 src/bisection_tree/bt.rs
--- a/src/bisection_tree/bt.rs	Thu May 01 08:40:33 2025 -0500
+++ b/src/bisection_tree/bt.rs	Thu May 01 13:06:58 2025 -0500
@@ -51,7 +51,7 @@
 #[derive(Clone, Debug)]
 pub(super) struct Branches<F: Num, D, A: Aggregator, const N: usize, const P: usize> {
     /// Point for subdivision of the (unstored) [`Cube`] corresponding to the node.
-    pub(super) branch_at: Loc<F, N>,
+    pub(super) branch_at: Loc<N, F>,
     /// Subnodes
     pub(super) nodes: [Node<F, D, A, N, P>; P],
 }
@@ -184,7 +184,7 @@
     ///
     /// This only takes the branch subdivision point $d$ into account, so is always succesfull.
     /// Thus, for this point, each branch corresponds to a quadrant of $ℝ^N$ relative to $d$.
-    fn get_node_index(&self, x: &Loc<F, N>) -> usize {
+    fn get_node_index(&self, x: &Loc<N, F>) -> usize {
         izip!(0..P, x.iter(), self.branch_at.iter())
             .map(|(i, x_i, branch_i)| if x_i > branch_i { 1 << i } else { 0 })
             .sum()
@@ -195,25 +195,25 @@
     /// This only takes the branch subdivision point $d$ into account, so is always succesfull.
     /// Thus, for this point, each branch corresponds to a quadrant of $ℝ^N$ relative to $d$.
     #[inline]
-    fn get_node(&self, x: &Loc<F, N>) -> &Node<F, D, A, N, P> {
+    fn get_node(&self, x: &Loc<N, F>) -> &Node<F, D, A, N, P> {
         &self.nodes[self.get_node_index(x)]
     }
 }
 
 /// An iterator over the $P=2^N$ subcubes of a [`Cube`] subdivided at a point `d`.
 pub(super) struct SubcubeIter<'b, F: Float, const N: usize, const P: usize> {
-    domain: &'b Cube<F, N>,
-    branch_at: Loc<F, N>,
+    domain: &'b Cube<N, F>,
+    branch_at: Loc<N, F>,
     index: usize,
 }
 
 /// Returns the `i`:th subcube of `domain` subdivided at `branch_at`.
 #[inline]
 fn get_subcube<F: Float, const N: usize>(
-    branch_at: &Loc<F, N>,
-    domain: &Cube<F, N>,
+    branch_at: &Loc<N, F>,
+    domain: &Cube<N, F>,
     i: usize,
-) -> Cube<F, N> {
+) -> Cube<N, F> {
     map2_indexed(branch_at, domain, move |j, &branch, &[start, end]| {
         if i & (1 << j) != 0 {
             [branch, end]
@@ -225,7 +225,7 @@
 }
 
 impl<'a, 'b, F: Float, const N: usize, const P: usize> Iterator for SubcubeIter<'b, F, N, P> {
-    type Item = Cube<F, N>;
+    type Item = Cube<N, F>;
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
         if self.index < P {
@@ -246,8 +246,8 @@
 {
     /// 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> + Support<F, N>>(
-        domain: &Cube<F, N>,
+    pub(super) fn new_with<S: LocalAnalysis<F, A, N> + Support<N, F>>(
+        domain: &Cube<N, F>,
         support: &S,
     ) -> Self {
         let hint = support.bisection_hint(domain);
@@ -272,7 +272,7 @@
     /// Returns an iterator over the subcubes of `domain` subdivided at the branching point
     /// of `self`.
     #[inline]
-    pub(super) fn iter_subcubes<'b>(&self, domain: &'b Cube<F, N>) -> SubcubeIter<'b, F, N, P> {
+    pub(super) fn iter_subcubes<'b>(&self, domain: &'b Cube<N, F>) -> SubcubeIter<'b, F, N, P> {
         SubcubeIter {
             domain: domain,
             branch_at: self.branch_at,
@@ -283,7 +283,7 @@
     /*
     /// Returns an iterator over all nodes and corresponding subcubes of `self`.
     #[inline]
-    pub(super) fn nodes_and_cubes<'a, 'b>(&'a self, domain : &'b Cube<F, N>)
+    pub(super) fn nodes_and_cubes<'a, 'b>(&'a self, domain : &'b Cube<N, F>)
     -> std::iter::Zip<Iter<'a, Node<F,D,A,N,P>>, SubcubeIter<'b, F, N, P>> {
         self.nodes.iter().zip(self.iter_subcubes(domain))
     }
@@ -293,7 +293,7 @@
     #[inline]
     pub(super) fn nodes_and_cubes_mut<'a, 'b>(
         &'a mut self,
-        domain: &'b Cube<F, N>,
+        domain: &'b Cube<N, F>,
     ) -> std::iter::Zip<IterMut<'a, Node<F, D, A, N, P>>, SubcubeIter<'b, F, N, P>> {
         let subcube_iter = self.iter_subcubes(domain);
         self.nodes.iter_mut().zip(subcube_iter)
@@ -303,10 +303,10 @@
     #[inline]
     fn recurse<'scope, 'smaller, 'refs>(
         &'smaller mut self,
-        domain: &'smaller Cube<F, N>,
+        domain: &'smaller Cube<N, F>,
         task_budget: TaskBudget<'scope, 'refs>,
-        guard: impl Fn(&Node<F, D, A, N, P>, &Cube<F, N>) -> bool + Send + 'smaller,
-        mut f: impl for<'a> FnMut(&mut Node<F, D, A, N, P>, &Cube<F, N>, TaskBudget<'smaller, 'a>)
+        guard: impl Fn(&Node<F, D, A, N, P>, &Cube<N, F>) -> bool + Send + 'smaller,
+        mut f: impl for<'a> FnMut(&mut Node<F, D, A, N, P>, &Cube<N, F>, TaskBudget<'smaller, 'a>)
             + Send
             + Copy
             + 'smaller,
@@ -332,9 +332,9 @@
     ///  * `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> + Support<F, N>>(
+    pub(super) fn insert<'refs, 'scope, M: Depth, S: LocalAnalysis<F, A, N> + Support<N, F>>(
         &mut self,
-        domain: &Cube<F, N>,
+        domain: &Cube<N, F>,
         d: D,
         new_leaf_depth: M,
         support: &S,
@@ -360,11 +360,11 @@
     pub(super) fn convert_aggregator<ANew, G>(
         self,
         generator: &G,
-        domain: &Cube<F, N>,
+        domain: &Cube<N, F>,
     ) -> Branches<F, D, ANew, N, P>
     where
         ANew: Aggregator,
-        G: SupportGenerator<F, N, Id = D>,
+        G: SupportGenerator<N, F, Id = D>,
         G::SupportType: LocalAnalysis<F, ANew, N>,
     {
         let branch_at = self.branch_at;
@@ -387,10 +387,10 @@
     pub(super) fn refresh_aggregator<'refs, 'scope, G>(
         &mut self,
         generator: &G,
-        domain: &Cube<F, N>,
+        domain: &Cube<N, F>,
         task_budget: TaskBudget<'scope, 'refs>,
     ) where
-        G: SupportGenerator<F, N, Id = D>,
+        G: SupportGenerator<N, F, Id = D>,
         G::SupportType: LocalAnalysis<F, A, N>,
     {
         self.recurse(
@@ -422,7 +422,7 @@
     /*
     /// Get leaf data
     #[inline]
-    pub(super) fn get_leaf_data(&self, x : &Loc<F, N>) -> Option<&Vec<D>> {
+    pub(super) fn get_leaf_data(&self, x : &Loc<N, F>) -> Option<&Vec<D>> {
         match self.data {
             NodeOption::Uninitialised => None,
             NodeOption::Leaf(ref data) => Some(data),
@@ -432,7 +432,7 @@
 
     /// Get leaf data iterator
     #[inline]
-    pub(super) fn get_leaf_data_iter(&self, x: &Loc<F, N>) -> Option<std::slice::Iter<'_, D>> {
+    pub(super) fn get_leaf_data_iter(&self, x: &Loc<N, F>) -> Option<std::slice::Iter<'_, D>> {
         match self.data {
             NodeOption::Uninitialised => None,
             NodeOption::Leaf(ref data) => Some(data.iter()),
@@ -459,9 +459,9 @@
     /// 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> + Support<F, N>>(
+    pub(super) fn insert<'refs, 'scope, M: Depth, S: LocalAnalysis<F, A, N> + Support<N, F>>(
         &mut self,
-        domain: &Cube<F, N>,
+        domain: &Cube<N, F>,
         d: D,
         new_leaf_depth: M,
         support: &S,
@@ -515,11 +515,11 @@
     pub(super) fn convert_aggregator<ANew, G>(
         mut self,
         generator: &G,
-        domain: &Cube<F, N>,
+        domain: &Cube<N, F>,
     ) -> Node<F, D, ANew, N, P>
     where
         ANew: Aggregator,
-        G: SupportGenerator<F, N, Id = D>,
+        G: SupportGenerator<N, F, Id = D>,
         G::SupportType: LocalAnalysis<F, ANew, N>,
     {
         // The mem::replace is needed due to the [`Drop`] implementation to extract self.data.
@@ -561,10 +561,10 @@
     pub(super) fn refresh_aggregator<'refs, 'scope, G>(
         &mut self,
         generator: &G,
-        domain: &Cube<F, N>,
+        domain: &Cube<N, F>,
         task_budget: TaskBudget<'scope, 'refs>,
     ) where
-        G: SupportGenerator<F, N, Id = D>,
+        G: SupportGenerator<N, F, Id = D>,
         G::SupportType: LocalAnalysis<F, A, N>,
     {
         match &mut self.data {
@@ -610,7 +610,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>:
+pub trait BTImpl<const N: usize, F: Float = f64>:
     std::fmt::Debug + Clone + GlobalAnalysis<F, Self::Agg>
 {
     /// The data type stored in the tree
@@ -621,7 +621,7 @@
     /// of the tree.
     type Agg: Aggregator;
     /// The type of the tree with the aggregator converted to `ANew`.
-    type Converted<ANew>: BTImpl<F, N, Data = Self::Data, Agg = ANew>
+    type Converted<ANew>: BTImpl<N, F, Data = Self::Data, Agg = ANew>
     where
         ANew: Aggregator;
 
@@ -629,7 +629,7 @@
     ///
     /// Every leaf node of the tree that intersects the `support` will contain a copy of
     /// `d`.
-    fn insert<S: LocalAnalysis<F, Self::Agg, N> + Support<F, N>>(
+    fn insert<S: LocalAnalysis<F, Self::Agg, N> + Support<N, F>>(
         &mut self,
         d: Self::Data,
         support: &S,
@@ -642,7 +642,7 @@
     fn convert_aggregator<ANew, G>(self, generator: &G) -> Self::Converted<ANew>
     where
         ANew: Aggregator,
-        G: SupportGenerator<F, N, Id = Self::Data>,
+        G: SupportGenerator<N, F, Id = Self::Data>,
         G::SupportType: LocalAnalysis<F, ANew, N>;
 
     /// Refreshes the aggregator of the three after possible changes to the support generator.
@@ -651,19 +651,19 @@
     /// into corresponding [`Support`]s.
     fn refresh_aggregator<G>(&mut self, generator: &G)
     where
-        G: SupportGenerator<F, N, Id = Self::Data>,
+        G: SupportGenerator<N, F, Id = Self::Data>,
         G::SupportType: LocalAnalysis<F, Self::Agg, 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>;
+    fn iter_at(&self, x: &Loc<N, F>) -> std::slice::Iter<'_, Self::Data>;
 
     /*
     /// Returns all [`Self::Data`] items at the point `x` of the domain.
-    fn data_at(&self, x : &Loc<F,N>) -> Arc<Vec<Self::Data>>;
+    fn data_at(&self, x : &Loc<N, F>) -> Arc<Vec<Self::Data>>;
     */
 
     /// Create a new tree on `domain` of indicated `depth`.
-    fn new(domain: Cube<F, N>, depth: Self::Depth) -> Self;
+    fn new(domain: Cube<N, F>, depth: Self::Depth) -> Self;
 }
 
 /// The main bisection tree structure.
@@ -679,7 +679,7 @@
     /// The depth of the tree (initial, before refinement)
     pub(super) depth: M,
     /// The domain of the toplevel node
-    pub(super) domain: Cube<F, N>,
+    pub(super) domain: Cube<N, F>,
     /// The toplevel node of the tree
     pub(super) topnode: <BTNodeLookup as BTNode<F, D, A, N>>::Node,
 }
@@ -693,7 +693,7 @@
             type Node = Node<F,D,A,$n,{pow(2, $n)}>;
         }
 
-        impl<M,F,D,A> BTImpl<F,$n> for BT<M,F,D,A,$n>
+        impl<M,F,D,A> BTImpl<$n, F> for BT<M,F,D,A,$n>
         where M : Depth,
               F : Float,
               D : 'static + Copy + Send + Sync + std::fmt::Debug,
@@ -703,7 +703,7 @@
             type Agg = A;
             type Converted<ANew> = BT<M,F,D,ANew,$n> where ANew : Aggregator;
 
-            fn insert<S: LocalAnalysis<F, A, $n> + Support<F, $n>>(
+            fn insert<S: LocalAnalysis<F, A, $n> + Support< $n, F>>(
                 &mut self,
                 d : D,
                 support : &S
@@ -721,7 +721,7 @@
 
             fn convert_aggregator<ANew, G>(self, generator : &G) -> Self::Converted<ANew>
             where ANew : Aggregator,
-                  G : SupportGenerator<F, $n, Id=D>,
+                  G : SupportGenerator< $n, F, Id=D>,
                   G::SupportType : LocalAnalysis<F, ANew, $n> {
                 let topnode = self.topnode.convert_aggregator(generator, &self.domain);
 
@@ -733,22 +733,22 @@
             }
 
             fn refresh_aggregator<G>(&mut self, generator : &G)
-            where G : SupportGenerator<F, $n, Id=Self::Data>,
+            where G : SupportGenerator< $n, F, Id=Self::Data>,
                 G::SupportType : LocalAnalysis<F, Self::Agg, $n> {
                 with_task_budget(|task_budget|
                     self.topnode.refresh_aggregator(generator, &self.domain, task_budget)
                 )
             }
 
-            /*fn data_at(&self, x : &Loc<F,$n>) -> Arc<Vec<D>> {
+            /*fn data_at(&self, x : &Loc<$n, F>) -> Arc<Vec<D>> {
                 self.topnode.get_leaf_data(x).unwrap_or_else(|| Arc::new(Vec::new()))
             }*/
 
-            fn iter_at(&self, x : &Loc<F,$n>) -> std::slice::Iter<'_, D> {
+            fn iter_at(&self, x : &Loc<$n, F>) -> std::slice::Iter<'_, D> {
                 self.topnode.get_leaf_data_iter(x).unwrap_or_else(|| [].iter())
             }
 
-            fn new(domain : Cube<F, $n>, depth : M) -> Self {
+            fn new(domain : Cube<$n, F>, depth : M) -> Self {
                 BT {
                     depth : depth,
                     domain : domain,