pointsource_algs: comparison src/kernels/base.rs

-:bd13c2ae3450
+:56c8adc32b09
 Bounds,
 LocalAnalysis,
 GlobalAnalysis,
 Bounded,
 };
-use alg_tools::mapping::Apply;
+use alg_tools::mapping::{Apply, Differentiable};
-use alg_tools::maputil::{array_init, map2};
+use alg_tools::maputil::{array_init, map2, map1_indexed};
 use alg_tools::sets::SetOrd;
 use crate::fourier::Fourier;
+use crate::types::Lipschitz;
 /// Representation of the product of two kernels.
 ///
 /// The kernels typically implement [`Support`] and [`Mapping`][alg_tools::mapping::Mapping].
 ///
 fn apply(&self, x : &'a Loc<F, N>) -> Self::Output {
 self.0.apply(x) * self.1.apply(x)
 }
 }
+impl<A, B, F : Float, const N : usize> Differentiable<Loc<F, N>>
+for SupportProductFirst<A, B>
+where A : for<'a> Apply<&'a Loc<F, N>, Output=F>
++ for<'a> Differentiable<&'a Loc<F, N>, Output=Loc<F, N>>,
+B : for<'a> Apply<&'a Loc<F, N>, Output=F>
++ for<'a> Differentiable<&'a Loc<F, N>, Output=Loc<F, N>> {
+type Output = Loc<F, N>;
+#[inline]
+fn differential(&self, x : Loc<F, N>) -> Self::Output {
+self.0.differential(&x) * self.1.apply(&x) + self.1.differential(&x) * self.0.apply(&x)
+}
+}
+impl<'a, A, B, F : Float, const N : usize> Differentiable<&'a Loc<F, N>>
+for SupportProductFirst<A, B>
+where A : Apply<&'a Loc<F, N>, Output=F>
++ Differentiable<&'a Loc<F, N>, Output=Loc<F, N>>,
+B : Apply<&'a Loc<F, N>, Output=F>
++ Differentiable<&'a Loc<F, N>, Output=Loc<F, N>> {
+type Output = Loc<F, N>;
+#[inline]
+fn differential(&self, x : &'a Loc<F, N>) -> Self::Output {
+self.0.differential(&x) * self.1.apply(&x) + self.1.differential(&x) * self.0.apply(&x)
+}
+}
 impl<'a, A, B, F : Float, const N : usize> Support<F, N>
 for SupportProductFirst<A, B>
 where A : Support<F, N>,
 B : Support<F, N> {
 #[inline]
 fn apply(&self, x : Loc<F, N>) -> Self::Output {
 self.0.apply(&x) + self.1.apply(&x)
 }
 }
+impl<'a, A, B, F : Float, const N : usize> Differentiable<&'a Loc<F, N>>
+for SupportSum<A, B>
+where A : Differentiable<&'a Loc<F, N>, Output=Loc<F, N>>,
+B : Differentiable<&'a Loc<F, N>, Output=Loc<F, N>> {
+type Output = Loc<F, N>;
+#[inline]
+fn differential(&self, x : &'a Loc<F, N>) -> Self::Output {
+self.0.differential(x) + self.1.differential(x)
+}
+}
+impl<A, B, F : Float, const N : usize> Differentiable<Loc<F, N>>
+for SupportSum<A, B>
+where A : for<'a> Differentiable<&'a Loc<F, N>, Output=Loc<F, N>>,
+B : for<'a> Differentiable<&'a Loc<F, N>, Output=Loc<F, N>> {
+type Output = Loc<F, N>;
+#[inline]
+fn differential(&self, x : Loc<F, N>) -> Self::Output {
+self.0.differential(&x) + self.1.differential(&x)
+}
+}
 impl<'a, A, B, F : Float, const N : usize> Support<F, N>
 for SupportSum<A, B>
 where A : Support<F, N>,
 B : Support<F, N>,
 Cube<F, N> : SetOrd {
 #[inline]
 fn local_analysis(&self, cube : &Cube<F, N>) -> Bounds<F> {
 self.0.local_analysis(cube) + self.1.local_analysis(cube)
 }
 }
+impl<F : Float, M : Copy, A, B> Lipschitz<M> for SupportSum<A, B>
+where A : Lipschitz<M, FloatType = F>,
+B : Lipschitz<M, FloatType = F> {
+type FloatType = F;
+fn lipschitz_factor(&self, m : M) -> Option<F> {
+match (self.0.lipschitz_factor(m), self.1.lipschitz_factor(m)) {
+(Some(l0), Some(l1)) => Some(l0 + l1),
+_ => None
+}
+}
+}
 /// Representation of the convolution of two kernels.
 ///
 /// The kernels typically implement [`Support`]s and [`Mapping`][alg_tools::mapping::Mapping].
 //
 pub A,
 /// Second kernel
 pub B
 );
+impl<F : Float, M, A, B> Lipschitz<M> for Convolution<A, B>
+where A : Bounded<F> ,
+B : Lipschitz<M, FloatType = F> {
+type FloatType = F;
+fn lipschitz_factor(&self, m : M) -> Option<F> {
+self.1.lipschitz_factor(m).map(|l| l * self.0.bounds().uniform())
+}
+}
 /// Representation of the autoconvolution of a kernel.
 ///
 /// The kernel typically implements [`Support`] and [`Mapping`][alg_tools::mapping::Mapping].
 ///
 /// Trait implementations have to be on a case-by-case basis.
 #[derive(Copy,Clone,Serialize,Debug,Eq,PartialEq)]
 pub struct AutoConvolution<A>(
 /// The kernel to be autoconvolved
 pub A
 );
+impl<F : Float, M, C> Lipschitz<M> for AutoConvolution<C>
+where C : Lipschitz<M, FloatType = F> + Bounded<F> {
+type FloatType = F;
+fn lipschitz_factor(&self, m : M) -> Option<F> {
+self.0.lipschitz_factor(m).map(|l| l * self.0.bounds().uniform())
+}
+}
 /// Representation a multi-dimensional product of a one-dimensional kernel.
 ///
 /// For $G: ℝ → ℝ$, this is the function $F(x\_1, …, x\_n) := \prod_{i=1}^n G(x\_i)$.
 /// The kernel $G$ typically implements [`Support`] and [`Mapping`][alg_tools::mapping::Mapping]
 where G : Apply<Loc<F, 1>, Output=F> {
 type Output = F;
 #[inline]
 fn apply(&self, x : Loc<F, N>) -> F {
 x.into_iter().map(|y| self.0.apply(Loc([y]))).product()
+}
+}
+impl<'a, G, F : Float, const N : usize> Differentiable<&'a Loc<F, N>>
+for UniformProduct<G, N>
+where G : Apply<Loc<F, 1>, Output=F> + Differentiable<Loc<F, 1>, Output=F> {
+type Output = Loc<F, N>;
+#[inline]
+fn differential(&self, x : &'a Loc<F, N>) -> Loc<F, N> {
+let vs = x.map(|y| self.0.apply(Loc([y])));
+product_differential(x, &vs, |y| self.0.differential(Loc([y])))
+}
+}
+/// Helper function to calulate the differential of $f(x)=∏_{i=1}^N g(x_i)$.
+///
+/// The vector `x` is the location, `vs` consists of the values `g(x_i)`, and
+/// `gd` calculates the derivative `g'`.
+#[inline]
+pub(crate) fn product_differential<F : Float, G : Fn(F) -> F, const N : usize>(
+x : &Loc<F, N>,
+vs : &Loc<F, N>,
+gd : G
+) -> Loc<F, N> {
+map1_indexed(x, |i, &y| {
+gd(y) * vs.iter()
+.zip(0..)
+.filter_map(|(v, j)| (j != i).then_some(*v))
+.product()
+}).into()
+}
+impl<G, F : Float, const N : usize> Differentiable<Loc<F, N>>
+for UniformProduct<G, N>
+where G : Apply<Loc<F, 1>, Output=F> + Differentiable<Loc<F, 1>, Output=F> {
+type Output = Loc<F, N>;
+#[inline]
+fn differential(&self, x : Loc<F, N>) -> Loc<F, N> {
+self.differential(&x)
 }
 }
 impl<G, F : Float, const N : usize> Support<F, N>
 for UniformProduct<G, N>

Mercurial > repos > pointsource_algs / file comparison

comparison: src/kernels/base.rs

src/kernels/base.rs