diff -r 495448cca603 -r 6aa955ad8122 src/bisection_tree/support.rs
--- a/src/bisection_tree/support.rs	Thu May 01 08:40:33 2025 -0500
+++ b/src/bisection_tree/support.rs	Thu May 01 13:06:58 2025 -0500
@@ -16,14 +16,14 @@
 /// A trait for working with the supports of [`Mapping`]s.
 ///
 /// `Mapping` is not a super-trait to allow more general use.
-pub trait Support<F: Num, const N: usize>: Sized + Sync + Send + 'static {
+pub trait Support<const N: usize, F: Num>: Sized + Sync + Send + 'static {
     /// Return a cube containing the support of the function represented by `self`.
     ///
     /// The hint may be larger than the actual support, but must contain it.
-    fn support_hint(&self) -> Cube<F, N>;
+    fn support_hint(&self) -> Cube<N, F>;
 
     /// Indicate whether `x` is in the support of the function represented by `self`.
-    fn in_support(&self, x: &Loc<F, N>) -> bool;
+    fn in_support(&self, x: &Loc<N, F>) -> bool;
 
     // Indicate whether `cube` is fully in the support of the function represented by `self`.
     //fn fully_in_support(&self, cube : &Cube<F,N>) -> bool;
@@ -39,13 +39,13 @@
     /// The default implementation returns `[None; N]`.
     #[inline]
     #[allow(unused_variables)]
-    fn bisection_hint(&self, cube: &Cube<F, N>) -> [Option<F>; N] {
+    fn bisection_hint(&self, cube: &Cube<N, F>) -> [Option<F>; N] {
         [None; N]
     }
 
     /// Translate `self` by `x`.
     #[inline]
-    fn shift(self, x: Loc<F, N>) -> Shift<Self, F, N> {
+    fn shift(self, x: Loc<N, F>) -> Shift<Self, N, F> {
         Shift {
             shift: x,
             base_fn: self,
@@ -55,46 +55,46 @@
 
 /// Shift of [`Support`] and [`Mapping`]; output of [`Support::shift`].
 #[derive(Copy, Clone, Debug, Serialize)] // Serialize! but not implemented by Loc.
-pub struct Shift<T, F, const N: usize> {
-    shift: Loc<F, N>,
+pub struct Shift<T, const N: usize, F = f64> {
+    shift: Loc<N, F>,
     base_fn: T,
 }
 
-impl<'a, T, V: Space, F: Float, const N: usize> Mapping<Loc<F, N>> for Shift<T, F, N>
+impl<'a, T, V: Space, F: Float, const N: usize> Mapping<Loc<N, F>> for Shift<T, N, F>
 where
-    T: Mapping<Loc<F, N>, Codomain = V>,
+    T: Mapping<Loc<N, F>, Codomain = V>,
 {
     type Codomain = V;
 
     #[inline]
-    fn apply<I: Instance<Loc<F, N>>>(&self, x: I) -> Self::Codomain {
+    fn apply<I: Instance<Loc<N, F>>>(&self, x: I) -> Self::Codomain {
         self.base_fn.apply(x.own() - &self.shift)
     }
 }
 
-impl<'a, T, V: Space, F: Float, const N: usize> DifferentiableImpl<Loc<F, N>> for Shift<T, F, N>
+impl<'a, T, V: Space, F: Float, const N: usize> DifferentiableImpl<Loc<N, F>> for Shift<T, N, F>
 where
-    T: DifferentiableMapping<Loc<F, N>, DerivativeDomain = V>,
+    T: DifferentiableMapping<Loc<N, F>, DerivativeDomain = V>,
 {
     type Derivative = V;
 
     #[inline]
-    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 {
         self.base_fn.differential(x.own() - &self.shift)
     }
 }
 
-impl<'a, T, F: Float, const N: usize> Support<F, N> for Shift<T, F, N>
+impl<'a, T, F: Float, const N: usize> Support<N, F> for Shift<T, N, F>
 where
-    T: Support<F, N>,
+    T: Support<N, F>,
 {
     #[inline]
-    fn support_hint(&self) -> Cube<F, N> {
+    fn support_hint(&self) -> Cube<N, F> {
         self.base_fn.support_hint().shift(&self.shift)
     }
 
     #[inline]
-    fn in_support(&self, x: &Loc<F, N>) -> bool {
+    fn in_support(&self, x: &Loc<N, F>) -> bool {
         self.base_fn.in_support(&(x - &self.shift))
     }
 
@@ -104,13 +104,13 @@
     // }
 
     #[inline]
-    fn bisection_hint(&self, cube: &Cube<F, N>) -> [Option<F>; N] {
+    fn bisection_hint(&self, cube: &Cube<N, F>) -> [Option<F>; N] {
         let base_hint = self.base_fn.bisection_hint(cube);
         map2(base_hint, &self.shift, |h, s| h.map(|z| z + *s))
     }
 }
 
-impl<'a, T, F: Float, const N: usize> GlobalAnalysis<F, Bounds<F>> for Shift<T, F, N>
+impl<'a, T, F: Float, const N: usize> GlobalAnalysis<F, Bounds<F>> for Shift<T, N, F>
 where
     T: LocalAnalysis<F, Bounds<F>, N>,
 {
@@ -120,20 +120,20 @@
     }
 }
 
-impl<'a, T, F: Float, const N: usize> LocalAnalysis<F, Bounds<F>, N> for Shift<T, F, N>
+impl<'a, T, F: Float, const N: usize> LocalAnalysis<F, Bounds<F>, N> for Shift<T, N, F>
 where
     T: LocalAnalysis<F, Bounds<F>, N>,
 {
     #[inline]
-    fn local_analysis(&self, cube: &Cube<F, N>) -> Bounds<F> {
+    fn local_analysis(&self, cube: &Cube<N, F>) -> Bounds<F> {
         self.base_fn.local_analysis(&cube.shift(&(-self.shift)))
     }
 }
 
 macro_rules! impl_shift_norm {
     ($($norm:ident)*) => { $(
-        impl<'a, T, F : Float, const N : usize> Norm<F, $norm> for Shift<T,F,N>
-        where T : Norm<F, $norm> {
+        impl<'a, T, F : Float, const N : usize> Norm<$norm, F> for Shift<T, N, F>
+        where T : Norm<$norm, F> {
             #[inline]
             fn norm(&self, n : $norm) -> F {
                 self.base_fn.norm(n)
@@ -144,18 +144,18 @@
 
 impl_shift_norm!(L1 L2 Linfinity);
 
-impl<'a, T, F: Float, C, const N: usize> Support<F, N> for Weighted<T, C>
+impl<'a, T, F: Float, C, const N: usize> Support<N, F> for Weighted<T, C>
 where
-    T: Support<F, N>,
+    T: Support<N, F>,
     C: Constant<Type = F>,
 {
     #[inline]
-    fn support_hint(&self) -> Cube<F, N> {
+    fn support_hint(&self) -> Cube<N, F> {
         self.base_fn.support_hint()
     }
 
     #[inline]
-    fn in_support(&self, x: &Loc<F, N>) -> bool {
+    fn in_support(&self, x: &Loc<N, F>) -> bool {
         self.base_fn.in_support(x)
     }
 
@@ -164,7 +164,7 @@
     // }
 
     #[inline]
-    fn bisection_hint(&self, cube: &Cube<F, N>) -> [Option<F>; N] {
+    fn bisection_hint(&self, cube: &Cube<N, F>) -> [Option<F>; N] {
         self.base_fn.bisection_hint(cube)
     }
 }
@@ -191,7 +191,7 @@
     C: Constant<Type = F>,
 {
     #[inline]
-    fn local_analysis(&self, cube: &Cube<F, N>) -> Bounds<F> {
+    fn local_analysis(&self, cube: &Cube<N, F>) -> Bounds<F> {
         let Bounds(lower, upper) = self.base_fn.local_analysis(cube);
         debug_assert!(lower <= upper);
         match self.weight.value() {
@@ -240,8 +240,8 @@
 
 macro_rules! impl_weighted_norm {
     ($($norm:ident)*) => { $(
-        impl<'a, T, F : Float> Norm<F, $norm> for Weighted<T,F>
-        where T : Norm<F, $norm> {
+        impl<'a, T, F : Float> Norm<$norm, F> for Weighted<T,F>
+        where T : Norm<$norm, F> {
             #[inline]
             fn norm(&self, n : $norm) -> F {
                 self.base_fn.norm(n) * self.weight.abs()
@@ -261,14 +261,14 @@
     pub T,
 );
 
-impl<'a, T, F: Float, const N: usize> Mapping<Loc<F, N>> for Normalised<T>
+impl<'a, T, F: Float, const N: usize> Mapping<Loc<N, F>> for Normalised<T>
 where
-    T: Norm<F, L1> + Mapping<Loc<F, N>, Codomain = F>,
+    T: Norm<L1, F> + Mapping<Loc<N, F>, Codomain = F>,
 {
     type Codomain = F;
 
     #[inline]
-    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 w = self.0.norm(L1);
         if w == F::ZERO {
             F::ZERO
@@ -278,17 +278,17 @@
     }
 }
 
-impl<'a, T, F: Float, const N: usize> Support<F, N> for Normalised<T>
+impl<'a, T, F: Float, const N: usize> Support<N, F> for Normalised<T>
 where
-    T: Norm<F, L1> + Support<F, N>,
+    T: Norm<L1, F> + Support<N, F>,
 {
     #[inline]
-    fn support_hint(&self) -> Cube<F, N> {
+    fn support_hint(&self) -> Cube<N, F> {
         self.0.support_hint()
     }
 
     #[inline]
-    fn in_support(&self, x: &Loc<F, N>) -> bool {
+    fn in_support(&self, x: &Loc<N, F>) -> bool {
         self.0.in_support(x)
     }
 
@@ -297,14 +297,14 @@
     // }
 
     #[inline]
-    fn bisection_hint(&self, cube: &Cube<F, N>) -> [Option<F>; N] {
+    fn bisection_hint(&self, cube: &Cube<N, F>) -> [Option<F>; N] {
         self.0.bisection_hint(cube)
     }
 }
 
 impl<'a, T, F: Float> GlobalAnalysis<F, Bounds<F>> for Normalised<T>
 where
-    T: Norm<F, L1> + GlobalAnalysis<F, Bounds<F>>,
+    T: Norm<L1, F> + GlobalAnalysis<F, Bounds<F>>,
 {
     #[inline]
     fn global_analysis(&self) -> Bounds<F> {
@@ -318,10 +318,10 @@
 
 impl<'a, T, F: Float, const N: usize> LocalAnalysis<F, Bounds<F>, N> for Normalised<T>
 where
-    T: Norm<F, L1> + LocalAnalysis<F, Bounds<F>, N>,
+    T: Norm<L1, F> + LocalAnalysis<F, Bounds<F>, N>,
 {
     #[inline]
-    fn local_analysis(&self, cube: &Cube<F, N>) -> Bounds<F> {
+    fn local_analysis(&self, cube: &Cube<N, F>) -> Bounds<F> {
         let Bounds(lower, upper) = self.0.local_analysis(cube);
         debug_assert!(lower <= upper);
         let w = self.0.norm(L1);
@@ -330,9 +330,9 @@
     }
 }
 
-impl<'a, T, F: Float> Norm<F, L1> for Normalised<T>
+impl<'a, T, F: Float> Norm<L1, F> for Normalised<T>
 where
-    T: Norm<F, L1>,
+    T: Norm<L1, F>,
 {
     #[inline]
     fn norm(&self, _: L1) -> F {
@@ -347,8 +347,8 @@
 
 macro_rules! impl_normalised_norm {
     ($($norm:ident)*) => { $(
-        impl<'a, T, F : Float> Norm<F, $norm> for Normalised<T>
-        where T : Norm<F, $norm> + Norm<F, L1> {
+        impl<'a, T, F : Float> Norm<$norm, F> for Normalised<T>
+        where T : Norm<$norm, F> + Norm<L1, F> {
             #[inline]
             fn norm(&self, n : $norm) -> F {
                 let w = self.0.norm(L1);
@@ -361,26 +361,26 @@
 impl_normalised_norm!(L2 Linfinity);
 
 /*
-impl<F : Num, S : Support<F, N>, const N : usize> LocalAnalysis<F, NullAggregator, N> for S {
-    fn local_analysis(&self, _cube : &Cube<F, N>) -> NullAggregator { NullAggregator }
+impl<F : Num, S : Support< N, F>, const N : usize> LocalAnalysis<F, NullAggregator, N> for S {
+    fn local_analysis(&self, _cube : &Cube<N, F>) -> NullAggregator { NullAggregator }
 }
 
 impl<F : Float, S : Bounded<F>, const N : usize> LocalAnalysis<F, Bounds<F>, N> for S {
     #[inline]
-    fn local_analysis(&self, cube : &Cube<F, N>) -> Bounds<F> {
+    fn local_analysis(&self, cube : &Cube<N, F>) -> Bounds<F> {
         self.bounds(cube)
     }
 }*/
 
 /// Generator of [`Support`]-implementing component functions based on low storage requirement
 /// [ids][`Self::Id`].
-pub trait SupportGenerator<F: Float, const N: usize>:
+pub trait SupportGenerator<const N: usize, F: Float = f64>:
     MulAssign<F> + DivAssign<F> + Neg<Output = Self> + Clone + Sync + Send + 'static
 {
     /// The identification type
     type Id: 'static + Copy;
     /// The type of the [`Support`] (often also a [`Mapping`]).
-    type SupportType: 'static + Support<F, N>;
+    type SupportType: 'static + Support<N, F>;
     /// An iterator over all the [`Support`]s of the generator.
     type AllDataIter<'a>: Iterator<Item = (Self::Id, Self::SupportType)>
     where