pointsource_algs: comparison src/sliding

-:afb3ce40cff6
+:66b8ac0ebe00
 use alg_tools::instance::Space;
 use alg_tools::iterate::AlgIteratorFactory;
 use alg_tools::mapping::{DifferentiableMapping, DifferentiableRealMapping, Mapping, RealMapping};
 use alg_tools::nalgebra_support::ToNalgebraRealField;
 use alg_tools::norms::Norm;
+use alg_tools::sets::{Set, Cube};
 use anyhow::ensure;
 use std::ops::ControlFlow;
 /// Transport settings for [`pointsource_sliding_fb_reg`].
 #[derive(Clone, Copy, Eq, PartialEq, Serialize, Deserialize, Debug)]
 F: Float + ToNalgebraRealField,
 Reg: SlidingRegTerm<Domain, F>,
 Domain: Space + Clone,
 {
 type TransportStepLength;
+type Dom : Set<Domain>;
 /// Constrution of initial transport `γ1` from initial measure `μ` and `v=F'(μ)`
 /// with step lengh τ and transport step length `θ_or_adaptive`.
 fn initial_transport(
 &self,
 ε: F,
 τ: F,
 τθ_or_adaptive: &mut Self::TransportStepLength,
 v: &PreadjointCodomain,
 tconfig: &TransportConfig<F>,
+domain: Option<&Self::Dom>,
 );
 /// A posteriori transport adaptation.
 fn aposteriori_transport(
 &self,
 M: MinMaxMapping<Loc<N, F>, F> + DifferentiableRealMapping<N, F>,
 Reg: SlidingRegTerm<Loc<N, F>, F>,
 RNDM<N, F>: SpikeMerging<F>,
 {
 type TransportStepLength = TransportStepLength<F>;
+type Dom = Cube<N, F>;
 fn get_transport_steplength(
 &self,
 (ℓ_F, maybe_ℓ_gradv, _maybe_transport_lip): (DynResult<F>, DynResult<F>, DynResult<F>),
 tconfig: &TransportConfig<F>,
 _ε: F,
 _τ: F,
 τθ_or_adaptive: &mut TransportStepLength<F>,
 v: &M,
 tconfig: &TransportConfig<F>,
+domain: Option<&Cube<N, F>>,
 ) {
-γ.do_init_transport(v, μ, τθ_or_adaptive, tconfig);
+γ.do_init_transport(v, μ, τθ_or_adaptive, tconfig, domain);
 }
 fn aposteriori_transport(
 &self,
 γ: &mut Transport<Loc<N, F>, F>,
 Reg: SlidingRegTerm<Loc<N, F>, F>,
 Self: ProxPenalty<Loc<N, F>, M, Reg, F>,
 RNDM<N, F>: SpikeMerging<F>,
 {
 type TransportStepLength = TransportStepLength<F>;
+type Dom = Cube<N, F>;
 fn get_transport_steplength(
 &self,
 (ℓ_F, maybe_ℓ_gradv, _maybe_transport_lip): (DynResult<F>, DynResult<F>, DynResult<F>),
 tconfig: &TransportConfig<F>,
 _ε: F,
 _τ: F,
 τθ_or_adaptive: &mut TransportStepLength<F>,
 v: &M,
 tconfig: &TransportConfig<F>,
+domain: Option<&Cube<N, F>>,
 ) {
-γ.do_init_transport(v, μ, τθ_or_adaptive, tconfig);
+γ.do_init_transport(v, μ, τθ_or_adaptive, tconfig, domain);
 }
 fn aposteriori_transport(
 &self,
 γ: &mut Transport<Loc<N, F>, F>,
 &mut self,
 v: &D,
 μ: &RNDM<N, F>,
 τθ_or_adaptive: &mut TransportStepLength<F>,
 tconfig: &TransportConfig<F>,
+domain: Option<&Cube<N, F>>,
 ) where
 D: DifferentiableRealMapping<N, F>,
 {
 use TransportStepLength::*;
 let mut changes = false;
 for ρ in self.iter_mut() {
 if ρ.fail_count < tconfig.max_fail {
 let dv_x = v.differential(&ρ.x);
 let g = &dv_x * (ρ.α_γ.signum() * τθ);
-ρ.y = ρ.x - g;
+let tmp = ρ.x - g;
+ρ.y = if domain.is_none_or(|d| d.contains(&tmp)) { tmp } else { ρ.x };
 let n = g.norm2();
 if n >= F::EPSILON {
 // Estimate Lipschitz factor of ∇v
 let this_ℓ_gradv = (dv_x - v.differential(&ρ.y)).norm2() / n;
 *adaptive_ℓ_gradv = adaptive_ℓ_gradv.max(this_ℓ_gradv);
 };
 if let Some(τθ) = simple_τθ {
 for ρ in self.iter_mut() {
 if ρ.fail_count <= tconfig.max_fail {
-ρ.y = ρ.x - v.differential(&ρ.x) * (ρ.α_γ.signum() * τθ);
+let tmp = ρ.x - v.differential(&ρ.x) * (ρ.α_γ.signum() * τθ);
+ρ.y = if domain.is_none_or(|d| d.contains(&tmp)) { tmp } else { ρ.x };
 }
 }
 }
 }
 }
 /// Iteratively solve the pointsource localisation problem using sliding forward-backward
 /// splitting
 ///
-/// The parametrisation is as for [`pointsource_fb_reg`].
+/// The parametrisation is as for [`pointsource_fb_reg`], except an additional domain restriction
+/// may be given.
 /// Inertia is currently not supported.
 #[replace_float_literals(F::cast_from(literal))]
-pub fn pointsource_sliding_fb_reg<F, I, Dat, Reg, Plot, P, const N: usize>(
+pub fn pointsource_sliding_fb_dom<F, I, Dat, Reg, Plot, P, const N: usize>(
 f: &Dat,
 reg: &Reg,
 prox_penalty: &P,
 config: &SlidingFBConfig<F>,
 iterator: I,
 mut plotter: Plot,
 μ0: Option<RNDM<N, F>>,
+domain: Option<&P::Dom>,
 ) -> DynResult<RNDM<N, F>>
 where
 F: Float + ToNalgebraRealField,
 I: AlgIteratorFactory<IterInfo<F>>,
 Dat: DifferentiableMapping<RNDM<N, F>, Codomain = F> + BoundedCurvature<F>,
 ε,
 τ,
 &mut τθ_or_adaptive,
 &v,
 &config.transport,
+domain
 );
 let mut attempts = 0;
 // Solve finite-dimensional subproblem several times until the dual variable for the
 }
 //postprocess(μ, &config.insertion, f)
 postprocess(μ, &config.insertion, |μ̃| f.apply(μ̃))
 }
+#[deprecated]
+/// Version of `pointsource_sliding_fb` without domain restriction
+pub fn pointsource_sliding_fb_reg<F, I, Dat, Reg, Plot, P, const N: usize>(
+f: &Dat,
+reg: &Reg,
+prox_penalty: &P,
+config: &SlidingFBConfig<F>,
+iterator: I,
+plotter: Plot,
+μ0: Option<RNDM<N, F>>,
+) -> DynResult<RNDM<N, F>>
+where
+F: Float + ToNalgebraRealField,
+I: AlgIteratorFactory<IterInfo<F>>,
+Dat: DifferentiableMapping<RNDM<N, F>, Codomain = F> + BoundedCurvature<F>,
+Dat::DerivativeDomain:
+DifferentiableRealMapping<N, F> + ClosedMul<F> + MinMaxMapping<Loc<N, F>, F>,
+//for<'a> Dat::Differential<'a>: Lipschitz<&'a P, FloatType = F>,
+RNDM<N, F>: SpikeMerging<F>,
+Reg: SlidingRegTerm<Loc<N, F>, F>,
+P: TransportProxPenalty<Loc<N, F>, Dat::DerivativeDomain, Reg, F> + StepLengthBound<F, Dat>,
+Plot: Plotter<P::ReturnMapping, Dat::DerivativeDomain, RNDM<N, F>>,
+{
+pointsource_sliding_fb_dom(f, reg, prox_penalty, config, iterator, plotter, μ0, None)
+}

comparison: src/sliding_fb.rs

src/sliding_fb.rs

Mercurial > repos > pointsource_algs / file comparison

comparison: src/sliding_fb.rs

src/sliding_fb.rs