--- a/src/bisection_tree/btfn.rs Tue Feb 20 12:33:16 2024 -0500
+++ b/src/bisection_tree/btfn.rs Mon Feb 03 19:22:16 2025 -0500
@@ -4,7 +4,10 @@
use std::marker::PhantomData;
use std::sync::Arc;
use crate::types::Float;
-use crate::mapping::{Apply, Mapping};
+use crate::mapping::{
+ Instance, Mapping, DifferentiableImpl, DifferentiableMapping, Space,
+ BasicDecomposition,
+};
//use crate::linops::{Apply, Linear};
use crate::sets::Set;
use crate::sets::Cube;
@@ -40,10 +43,22 @@
}
impl<F : Float, G, BT, const N : usize>
+Space for BTFN<F, G, BT, N>
+where
+ G : SupportGenerator<F, N, Id=BT::Data>,
+ G::SupportType : LocalAnalysis<F, BT::Agg, N>,
+ BT : BTImpl<F, N>
+{
+ type Decomp = BasicDecomposition;
+}
+
+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> {
+where
+ G : SupportGenerator<F, N, Id=BT::Data>,
+ G::SupportType : LocalAnalysis<F, BT::Agg, N>,
+ BT : BTImpl<F, N>
+{
/// Create a new BTFN from a support generator and a pre-initialised bisection tree.
///
@@ -386,42 +401,52 @@
make_btfn_unaryop!(Neg, neg);
-
-
//
-// Mapping
+// Apply, Mapping, Differentiate
//
-impl<'a, F : Float, G, BT, V, const N : usize> Apply<&'a Loc<F, N>>
+impl<F : Float, G, BT, V, const N : usize> Mapping<Loc<F, N>>
for BTFN<F, 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>,
- V : Sum {
+where
+ BT : BTImpl<F, N>,
+ G : SupportGenerator<F, N, Id=BT::Data>,
+ G::SupportType : LocalAnalysis<F, BT::Agg, N> + Mapping<Loc<F, N>, Codomain = V>,
+ V : Sum + Space,
+{
- type Output = V;
+ type Codomain = V;
- fn apply(&self, x : &'a Loc<F, N>) -> Self::Output {
- self.bt.iter_at(x)
- .map(|&d| self.generator.support_for(d).apply(x)).sum()
+ fn apply<I : Instance<Loc<F,N>>>(&self, x : I) -> Self::Codomain {
+ let xc = x.cow();
+ self.bt.iter_at(&*xc)
+ .map(|&d| self.generator.support_for(d).apply(&*xc)).sum()
}
}
-impl<F : Float, G, BT, V, const N : usize> Apply<Loc<F, N>>
+impl<F : Float, G, BT, V, const N : usize> DifferentiableImpl<Loc<F, N>>
for BTFN<F, 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>,
- V : Sum {
+where
+ BT : BTImpl<F, N>,
+ G : SupportGenerator<F, N, Id=BT::Data>,
+ G::SupportType : LocalAnalysis<F, BT::Agg, N>
+ + DifferentiableMapping<Loc<F, N>, DerivativeDomain = V>,
+ V : Sum + Space,
+{
- type Output = V;
+ type Derivative = V;
- fn apply(&self, x : Loc<F, N>) -> Self::Output {
- self.bt.iter_at(&x)
- .map(|&d| self.generator.support_for(d).apply(x)).sum()
+ fn differential_impl<I : Instance<Loc<F, N>>>(&self, x :I) -> Self::Derivative {
+ let xc = x.cow();
+ self.bt.iter_at(&*xc)
+ .map(|&d| self.generator.support_for(d).differential(&*xc))
+ .sum()
}
}
+//
+// GlobalAnalysis
+//
+
impl<F : Float, G, BT, const N : usize> GlobalAnalysis<F, BT::Agg>
for BTFN<F, G, BT, N>
where BT : BTImpl<F, N>,
@@ -480,7 +505,7 @@
///
/// `U` is the domain, generally [`Loc`]`<F, N>`, and `F` the type of floating point numbers.
/// `Self` is generally a set of `U`, for example, [`Cube`]`<F, N>`.
-pub trait P2Minimise<U, F : Float> : Set<U> {
+pub trait P2Minimise<U : Space, F : Float> : Set<U> {
/// Minimise `g` over the set presented by `Self`.
///
/// The function returns `(x, v)` where `x` is the minimiser `v` an approximation of `g(x)`.
@@ -806,7 +831,7 @@
impl<F : Float, G, BT, const N : usize> BTFN<F, G, BT, N>
where BT : BTSearch<F, N, Agg=Bounds<F>>,
G : SupportGenerator<F, N, Id=BT::Data>,
- G::SupportType : Mapping<Loc<F, N>,Codomain=F>
+ G::SupportType : Mapping<Loc<F, N>, Codomain=F>
+ LocalAnalysis<F, Bounds<F>, N>,
Cube<F, N> : P2Minimise<Loc<F, N>, F> {
