pointsource_algs: comparison src/sliding

-:4f468d35fa29
+:32328a74c790
 use crate::prox_penalty::{ProxPenalty, StepLengthBound};
 use crate::regularisation::SlidingRegTerm;
 use crate::types::*;
 use alg_tools::error::DynResult;
 use alg_tools::euclidean::Euclidean;
+use alg_tools::instance::{ClosedSpace, Instance};
 use alg_tools::iterate::AlgIteratorFactory;
 use alg_tools::mapping::{DifferentiableMapping, DifferentiableRealMapping};
 use alg_tools::nalgebra_support::ToNalgebraRealField;
 use alg_tools::norms::Norm;
 use anyhow::ensure;
 pub transport: TransportConfig<F>,
 /// Generic parameters
 pub insertion: InsertionConfig<F>,
 /// Guess for curvature bound calculations.
 pub guess: BoundedCurvatureGuess,
+/// Always adaptive step length
+pub always_adaptive_τ: bool,
+}
+impl<'a, F: Float> Into<FBConfig<F>> for &'a SlidingFBConfig<F> {
+fn into(self) -> FBConfig<F> {
+let SlidingFBConfig { τ0, σp0, insertion, always_adaptive_τ, .. } = *self;
+FBConfig { τ0, σp0, insertion, always_adaptive_τ }
+}
 }
 #[replace_float_literals(F::cast_from(literal))]
 impl<F: Float> Default for SlidingFBConfig<F> {
 fn default() -> Self {
 τ0: 0.99,
 σp0: 0.99,
 transport: Default::default(),
 insertion: Default::default(),
 guess: BoundedCurvatureGuess::BetterThanZero,
+always_adaptive_τ: false,
 }
 }
 }
 /// Internal type of adaptive transport step length calculation
 ) -> 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>,
+Dat::DerivativeDomain:
-//for<'a> Dat::Differential<'a>: Lipschitz<&'a P, FloatType = F>,
+ClosedMul<F> + DifferentiableRealMapping<N, F, Codomain = F> + ClosedSpace,
 RNDM<N, F>: SpikeMerging<F>,
 Reg: SlidingRegTerm<Loc<N, F>, F>,
 P: ProxPenalty<Loc<N, F>, Dat::DerivativeDomain, Reg, F> + StepLengthBound<F, Dat>,
 Plot: Plotter<P::ReturnMapping, Dat::DerivativeDomain, RNDM<N, F>>,
+for<'a> &'a Dat::DerivativeDomain: Instance<Dat::DerivativeDomain>,
 {
 // Check parameters
 ensure!(config.τ0 > 0.0, "Invalid step length parameter");
 config.transport.check()?;
 // let opAnorm = opA.opnorm_bound(Radon, L2);
 //let max_transport = config.max_transport.scale
 //                    * reg.radon_norm_bound(b.norm2_squared() / 2.0);
 //let ℓ = opA.transport.lipschitz_factor(L2Squared) * max_transport;
 let ℓ = 0.0;
-let τ = config.τ0 / prox_penalty.step_length_bound(&f)?;
+let mut adaptive_τ = AdaptiveStepLength::new(f, prox_penalty, &config.into())?;
+let τ = adaptive_τ.current();
+println!("TODO: τ in calculate_θ should be adaptive");
 let (maybe_ℓ_F, maybe_transport_lip) = f.curvature_bound_components(config.guess);
 let transport_lip = maybe_transport_lip?;
 let calculate_θ = |ℓ_F, max_transport| {
 let ℓ_r = transport_lip * max_transport;
 config.transport.θ0 / (τ * (ℓ + ℓ_F + ℓ_r))
 let mut stats = IterInfo::new();
 // Run the algorithm
 for state in iterator.iter_init(|| full_stats(&μ, ε, stats.clone())) {
 // Calculate initial transport
-let v = f.differential(&μ);
+let (fμ, v) = f.apply_and_differential(&μ);
+let τ = adaptive_τ.update(&μ, fμ, &v);
 let (μ_base_masses, mut μ_base_minus_γ0) =
 initial_transport(&mut γ1, &mut μ, τ, &mut θ_or_adaptive, v);
 // Solve finite-dimensional subproblem several times until the dual variable for the
 // regularisation term conforms to the assumptions made for the transport above.
 &config.transport,
 ) {
 break 'adapt_transport (maybe_d, within_tolerances, τv̆);
 }
 };
+// We don't treat merge in adaptive Lipschitz.
+println!("WARNING: finish_step does not work with sliding");
+adaptive_τ.finish_step(&μ);
 stats.untransported_fraction = Some({
 assert_eq!(μ_base_masses.len(), γ1.len());
 let (a, b) = stats.untransported_fraction.unwrap_or((0.0, 0.0));
 let source = μ_base_masses.iter().map(|v| v.abs()).sum();

comparison: src/sliding_fb.rs

src/sliding_fb.rs

Mercurial > repos > pointsource_algs / file comparison

comparison: src/sliding_fb.rs

src/sliding_fb.rs