diff -r edb95d2b83cc -r d2acaaddd9af src/bisection_tree/support.rs
--- a/src/bisection_tree/support.rs	Sun Nov 10 09:02:57 2024 -0500
+++ b/src/bisection_tree/support.rs	Tue Dec 31 09:12:43 2024 -0500
@@ -10,18 +10,17 @@
 use crate::sets::Cube;
 use crate::loc::Loc;
 use super::aggregator::Bounds;
-use crate::norms::{Norm, L1, L2, Linfinity};
+use crate::norms::{Norm, L1, L2, Linfinity, HasScalarField, HasRealField};
 
 /// A trait for encoding constant [`Float`] values
-pub trait Constant : Copy + Sync + Send + 'static + std::fmt::Debug + Into<Self::Type> {
-    /// The type of the value
-    type Type : Float;
+pub trait Constant : Copy + Sync + Send + 'static
+                     + std::fmt::Debug + HasRealField
+                     + Into<Self::Field> {
     /// Returns the value of the constant
-    fn value(&self) -> Self::Type;
+    fn value(&self) -> Self::Field;
 }
 
 impl<F : Float> Constant for F {
-    type Type = F;
     #[inline]
     fn value(&self) -> F { *self }
 }
@@ -30,17 +29,17 @@
 /// A trait for working with the supports of [`Apply`]s.
 ///
 /// Apply 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> : Sized + Sync + Send + 'static + HasRealField {
     /// 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<Self::Field,N>;
 
     /// 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<Self::Field,N>) -> 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;
+    //fn fully_in_support(&self, cube : &Cube<Self::Field,N>) -> bool;
 
     /// Return an optional hint for bisecting the support.
     ///
@@ -53,19 +52,19 @@
     /// 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<Self::Field, N>) -> [Option<Self::Field>; N] {
         [None; N]
     }
 
     /// Translate `self` by `x`.
     #[inline]
-    fn shift(self, x : Loc<F, N>) -> Shift<Self, F, N> {
+    fn shift(self, x : Loc<Self::Field, N>) -> Shift<Self, Self::Field, N> {
         Shift { shift : x, base_fn : self }
     }
 
     /// Multiply `self` by the scalar `a`.
     #[inline]
-    fn weigh<C : Constant<Type=F>>(self, a : C) -> Weighted<Self, C> {
+    fn weigh<C : Constant<RealField=Self::RealField>>(self, a : C) -> Weighted<Self, C> {
         Weighted { weight : a, base_fn : self }
     }
 }
@@ -74,7 +73,7 @@
 ///
 /// Typically `A` is an [`Aggregator`][super::aggregator::Aggregator] such as
 /// [`Bounds`][super::aggregator::Bounds].
-pub trait GlobalAnalysis<F : Num, A> {
+pub trait GlobalAnalysis<A> {
     /// Perform global analysis of the property `A` of `Self`.
     ///
     /// As an example, in the case of `A` being [`Bounds`][super::aggregator::Bounds],
@@ -83,26 +82,18 @@
     fn global_analysis(&self) -> A;
 }
 
-// default impl<F, A, N, L> GlobalAnalysis<F, A, N> for L
-// where L : LocalAnalysis<F, A, N> {
-//     #[inline]
-//     fn global_analysis(&self) -> Bounds<F> {
-//         self.local_analysis(&self.support_hint())
-//     }
-// }
-
 /// Trait for locally analysing a property `A` of a [`Apply`] (implementing [`Support`])
 /// within a [`Cube`].
 ///
 /// Typically `A` is an [`Aggregator`][super::aggregator::Aggregator] such as
 /// [`Bounds`][super::aggregator::Bounds].
-pub trait LocalAnalysis<F : Num, A, const N : usize> : GlobalAnalysis<F, A> + Support<F, N> {
+pub trait LocalAnalysis<A, LocalSet> : GlobalAnalysis<A> {
     /// Perform local analysis of the property `A` of `Self`.
     ///
     /// As an example, in the case of `A` being [`Bounds`][super::aggregator::Bounds],
     /// this function will return upper and lower bounds within `cube` for the mapping
     /// represented by `self`.
-    fn local_analysis(&self, cube : &Cube<F, N>) -> A;
+    fn local_analysis(&self, cube : &LocalSet) -> A;
 }
 
 /// Trait for determining the upper and lower bounds of an float-valued [`Apply`].
@@ -110,15 +101,15 @@
 /// This is a blanket-implemented alias for [`GlobalAnalysis`]`<F, Bounds<F>>`
 /// [`Apply`] is not a supertrait to allow flexibility in the implementation of either
 /// reference or non-reference arguments.
-pub trait Bounded<F : Float> : GlobalAnalysis<F, Bounds<F>> {
+pub trait Bounded : GlobalAnalysis<Bounds<Self::Field>> + HasScalarField {
     /// Return lower and upper bounds for the values of of `self`.
     #[inline]
-    fn bounds(&self) -> Bounds<F> {
+    fn bounds(&self) -> Bounds<Self::Field> {
         self.global_analysis()
     }
 }
 
-impl<F : Float, T : GlobalAnalysis<F, Bounds<F>>> Bounded<F> for T { }
+impl<T : GlobalAnalysis<Bounds<Self::Field>> + HasScalarField> Bounded for T { }
 
 /// Shift of [`Support`] and [`Apply`]; output of [`Support::shift`].
 #[derive(Copy,Clone,Debug,Serialize)] // Serialize! but not implemented by Loc.
@@ -127,6 +118,10 @@
     base_fn : T,
 }
 
+impl<T, F : Num, const N : usize>  HasScalarField for Shift<T, F, N> {
+    type Field = F;
+}
+
 impl<'a, T, V, F : Float, const N : usize> Apply<&'a Loc<F, N>> for Shift<T,F,N>
 where T : Apply<Loc<F, N>, Output=V> {
     type Output = V;
@@ -145,7 +140,8 @@
     }
 }
 
-impl<'a, T, V, F : Float, const N : usize> Differentiable<&'a Loc<F, N>> for Shift<T,F,N>
+impl<'a, T, V : HasRealField<RealField=F>, F : Float, const N : usize>
+Differentiable<&'a Loc<F, N>> for Shift<T,F,N>
 where T : Differentiable<Loc<F, N>, Derivative=V> {
     type Derivative = V;
     #[inline]
@@ -154,7 +150,8 @@
     }
 }
 
-impl<'a, T, V, F : Float, const N : usize> Differentiable<Loc<F, N>> for Shift<T,F,N>
+impl<'a, T, V : HasRealField<RealField=F>, F : Float, const N : usize>
+Differentiable<Loc<F, N>> for Shift<T,F,N>
 where T : Differentiable<Loc<F, N>, Derivative=V> {
     type Derivative = V;
     #[inline]
@@ -163,8 +160,8 @@
     }
 }
 
-impl<'a, T, F : Float, const N : usize> Support<F,N> for Shift<T,F,N>
-where T : Support<F, N> {
+impl<'a, T, F : Float, const N : usize> Support<N> for Shift<T,F,N>
+where T : Support<N, RealField = F> {
     #[inline]
     fn support_hint(&self) -> Cube<F,N> {
         self.base_fn.support_hint().shift(&self.shift)
@@ -188,16 +185,17 @@
 
 }
 
-impl<'a, T, F : Float, const N : usize> GlobalAnalysis<F, Bounds<F>> for Shift<T,F,N>
-where T : LocalAnalysis<F, Bounds<F>, N> {
+impl<'a, T, F : Float, const N : usize> GlobalAnalysis<Bounds<F>> for Shift<T,F,N>
+where T : GlobalAnalysis<Bounds<F>> {
     #[inline]
     fn global_analysis(&self) -> Bounds<F> {
         self.base_fn.global_analysis()
     }
 }
 
-impl<'a, T, F : Float, const N : usize> LocalAnalysis<F, Bounds<F>, N> for Shift<T,F,N>
-where T : LocalAnalysis<F, Bounds<F>, N> {
+impl<'a, T, F : Float, const N : usize> LocalAnalysis<Bounds<F>, Cube<F, N>>
+for Shift<T,F,N>
+where T : LocalAnalysis<Bounds<F>, Cube<F, N>> {
     #[inline]
     fn local_analysis(&self, cube : &Cube<F, N>) -> Bounds<F> {
         self.base_fn.local_analysis(&cube.shift(&(-self.shift)))
@@ -206,10 +204,10 @@
 
 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, const N : usize> Norm<$norm> for Shift<T,T::Field,N>
+        where T : Norm<$norm> {
             #[inline]
-            fn norm(&self, n : $norm) -> F {
+            fn norm(&self, n : $norm) -> T::Field {
                 self.base_fn.norm(n)
             }
         }
@@ -228,10 +226,16 @@
     pub base_fn : T,
 }
 
+impl<T, C, F : Float> HasScalarField for Weighted<T, C>
+where T : HasRealField<RealField = F>,
+      C : Constant<RealField = F> {
+    type Field = F;
+}
+
 impl<'a, T, V, F : Float, C, const N : usize> Apply<&'a Loc<F, N>> for Weighted<T, C>
 where T : for<'b> Apply<&'b Loc<F, N>, Output=V>,
       V : std::ops::Mul<F,Output=V>,
-      C : Constant<Type=F> {
+      C : Constant<RealField=F> {
     type Output = V;
     #[inline]
     fn apply(&self, x : &'a Loc<F, N>) -> Self::Output {
@@ -242,7 +246,7 @@
 impl<'a, T, V, F : Float, C, const N : usize> Apply<Loc<F, N>> for Weighted<T, C>
 where T : Apply<Loc<F, N>, Output=V>,
       V : std::ops::Mul<F,Output=V>,
-      C : Constant<Type=F> {
+      C : Constant<RealField=F> {
     type Output = V;
     #[inline]
     fn apply(&self, x : Loc<F, N>) -> Self::Output {
@@ -250,10 +254,11 @@
     }
 }
 
-impl<'a, T, V, F : Float, C, const N : usize> Differentiable<&'a Loc<F, N>> for Weighted<T, C>
-where T : for<'b> Differentiable<&'b Loc<F, N>, Derivative=V>,
+impl<'a, T, V : HasRealField<RealField=F>, F : Float, C, const N : usize>
+Differentiable<&'a Loc<F, N>> for Weighted<T, C>
+where T : for<'b> Differentiable<&'b Loc<F, N>, Derivative=V, RealField=F>,
       V : std::ops::Mul<F, Output=V>,
-      C : Constant<Type=F> {
+      C : Constant<RealField=F> {
     type Derivative = V;
     #[inline]
     fn differential(&self, x : &'a Loc<F, N>) -> Self::Derivative {
@@ -261,10 +266,11 @@
     }
 }
 
-impl<'a, T, V, F : Float, C, const N : usize> Differentiable<Loc<F, N>> for Weighted<T, C>
-where T : Differentiable<Loc<F, N>, Derivative=V>,
+impl<'a, T, V : HasRealField<RealField = F>, F : Float, C, const N : usize>
+Differentiable<Loc<F, N>> for Weighted<T, C>
+where T : Differentiable<Loc<F, N>, Derivative=V, RealField = F>,
       V : std::ops::Mul<F, Output=V>,
-      C : Constant<Type=F> {
+      C : Constant<RealField=F> {
     type Derivative = V;
     #[inline]
     fn differential(&self, x : Loc<F, N>) -> Self::Derivative {
@@ -272,9 +278,9 @@
     }
 }
 
-impl<'a, T, F : Float, C, const N : usize> Support<F,N> for Weighted<T, C>
-where T : Support<F, N>,
-      C : Constant<Type=F> {
+impl<'a, T, F : Float, C, const N : usize> Support<N> for Weighted<T, C>
+where T : Support<N, RealField = F>,
+      C : Constant<RealField=F> {
 
     #[inline]
     fn support_hint(&self) -> Cube<F,N> {
@@ -296,9 +302,9 @@
     }
 }
 
-impl<'a, T, F : Float, C> GlobalAnalysis<F, Bounds<F>> for Weighted<T, C>
-where T : GlobalAnalysis<F, Bounds<F>>,
-      C : Constant<Type=F> {
+impl<'a, T, F : Float, C> GlobalAnalysis<Bounds<F>> for Weighted<T, C>
+where T : GlobalAnalysis<Bounds<F>>,
+      C : Constant<RealField=F> {
     #[inline]
     fn global_analysis(&self) -> Bounds<F> {
         let Bounds(lower, upper) = self.base_fn.global_analysis();
@@ -310,9 +316,10 @@
     }
 }
 
-impl<'a, T, F : Float, C, const N : usize> LocalAnalysis<F, Bounds<F>, N> for Weighted<T, C>
-where T : LocalAnalysis<F, Bounds<F>, N>,
-      C : Constant<Type=F> {
+impl<'a, T, F : Float, C, const N : usize> LocalAnalysis<Bounds<F>, Cube<F, N>>
+for Weighted<T, C>
+where T : LocalAnalysis<Bounds<F>, Cube<F, N>>,
+      C : Constant<RealField=F> {
     #[inline]
     fn local_analysis(&self, cube : &Cube<F, N>) -> Bounds<F> {
         let Bounds(lower, upper) = self.base_fn.local_analysis(cube);
@@ -358,8 +365,9 @@
 
 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> for Weighted<T,F>
+        where T : Norm<$norm, Field = F> {
+
             #[inline]
             fn norm(&self, n : $norm) -> F {
                 self.base_fn.norm(n) * self.weight.abs()
@@ -381,7 +389,7 @@
 );
 
 impl<'a, T, F : Float, const N : usize> Apply<&'a Loc<F, N>> for Normalised<T>
-where T : Norm<F, L1> + for<'b> Apply<&'b Loc<F, N>, Output=F> {
+where T : Norm<L1, Field=F> + for<'b> Apply<&'b Loc<F, N>, Output=F> {
     type Output = F;
     #[inline]
     fn apply(&self, x : &'a Loc<F, N>) -> Self::Output {
@@ -391,7 +399,7 @@
 }
 
 impl<'a, T, F : Float, const N : usize> Apply<Loc<F, N>> for Normalised<T>
-where T : Norm<F, L1> + Apply<Loc<F,N>, Output=F> {
+where T : Norm<L1, Field = F> + Apply<Loc<F,N>, Output=F> {
     type Output = F;
     #[inline]
     fn apply(&self, x : Loc<F, N>) -> Self::Output {
@@ -400,8 +408,8 @@
     }
 }
 
-impl<'a, T, F : Float, const N : usize> Support<F,N> for Normalised<T>
-where T : Norm<F, L1> + Support<F, N> {
+impl<'a, T, F : Float, const N : usize> Support<N> for Normalised<T>
+where T : Norm<L1> + Support<N, RealField = F> {
 
     #[inline]
     fn support_hint(&self) -> Cube<F,N> {
@@ -423,8 +431,8 @@
     }
 }
 
-impl<'a, T, F : Float> GlobalAnalysis<F, Bounds<F>> for Normalised<T>
-where T : Norm<F, L1> + GlobalAnalysis<F, Bounds<F>> {
+impl<'a, T, F : Float> GlobalAnalysis<Bounds<F>> for Normalised<T>
+where T : Norm<L1, Field = F> + GlobalAnalysis<Bounds<F>> {
     #[inline]
     fn global_analysis(&self) -> Bounds<F> {
         let Bounds(lower, upper) = self.0.global_analysis();
@@ -435,8 +443,9 @@
     }
 }
 
-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> {
+impl<'a, T, F : Float, const N : usize> LocalAnalysis<Bounds<F>, Cube<F, N>>
+for Normalised<T>
+where T : Norm<L1, Field = F> + LocalAnalysis<Bounds<F>, Cube<F, N>> {
     #[inline]
     fn local_analysis(&self, cube : &Cube<F, N>) -> Bounds<F> {
         let Bounds(lower, upper) = self.0.local_analysis(cube);
@@ -447,23 +456,26 @@
     }
 }
 
-impl<'a, T, F : Float> Norm<F, L1> for Normalised<T>
-where T : Norm<F, L1> {
+impl<'a, T> HasScalarField for Normalised<T> where T : HasScalarField {
+    type Field = T::Field;
+}
+
+impl<'a, T> Norm<L1> for Normalised<T> where T : Norm<L1> {
     #[inline]
-    fn norm(&self, _ : L1) -> F {
+    fn norm(&self, _ : L1) -> Self::Field {
         let w = self.0.norm(L1);
-        if w == F::ZERO { F::ZERO } else { F::ONE }
+        if w == Self::Field::ZERO { Self::Field::ZERO } else { Self::Field::ONE }
     }
 }
 
 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> Norm<$norm> for Normalised<T> where T : Norm<$norm> + Norm<L1> {
+
             #[inline]
-            fn norm(&self, n : $norm) -> F {
+            fn norm(&self, n : $norm) -> Self::Field {
                 let w = self.0.norm(L1);
-                if w == F::ZERO { F::ZERO } else { self.0.norm(n) / w }
+                if w == Self::Field::ZERO { Self::Field::ZERO } else { self.0.norm(n) / w }
             }
         }
     )* }
@@ -471,26 +483,16 @@
 
 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 : 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> {
-        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>
-: MulAssign<F> + DivAssign<F> + Neg<Output=Self> + Clone + Sync + Send + 'static {
+pub trait SupportGenerator<const N : usize>
+: MulAssign<Self::Field> + DivAssign<Self::Field> + Neg<Output=Self> + HasRealField
+  + Clone + Sync + Send + 'static {
     /// The identification type
     type Id : 'static + Copy;
     /// The type of the [`Support`] (often also a [`Apply`]).
-    type SupportType : 'static + Support<F, N>;
+    type SupportType : 'static + Support<N, RealField=Self::RealField>;
     /// An iterator over all the [`Support`]s of the generator.
     type AllDataIter<'a> : Iterator<Item=(Self::Id, Self::SupportType)> where Self : 'a;