pointsource_algs: comparison src/run.rs

-:51dbb2cc25d9
+:8d1c959432c8
 /*!
 This module provides [`RunnableExperiment`] for running chosen algorithms on a chosen experiment.
 */
-use crate::fb::{pointsource_fb_reg, pointsource_fista_reg, FBConfig, InsertionConfig};
+use crate::domain::{AdmissibleDomain, FullSpace};
+use crate::fb::{pointsource_fb_dom, pointsource_fista_reg, FBConfig, InsertionConfig};
 use crate::forward_model::sensor_grid::{
 //SensorGridBTFN,
 Sensor,
 SensorGrid,
 SensorGridBT,
 Spread,
 };
 use crate::forward_model::*;
-use crate::forward_pdps::{pointsource_fb_pair, pointsource_forward_pdps_pair, ForwardPDPSConfig};
+use crate::forward_pdps::{
+pointsource_fb_pair_dom, pointsource_forward_pdps_pair_dom, ForwardPDPSConfig,
+};
 use crate::frank_wolfe::{pointsource_fw_reg, FWConfig, FWVariant, RegTermFW};
 use crate::kernels::*;
 use crate::measures::merging::{SpikeMerging, SpikeMergingMethod};
 use crate::measures::*;
 use crate::pdps::{pointsource_pdps_reg, PDPSConfig};
 ProxPenalty, ProxTerm, RadonSquared, StepLengthBound, StepLengthBoundPD, StepLengthBoundPair,
 };
 use crate::regularisation::{NonnegRadonRegTerm, RadonRegTerm, Regularisation, SlidingRegTerm};
 use crate::seminorms::*;
 use crate::sliding_fb::{
-pointsource_sliding_fb_dom, SlidingFBConfig, TransportConfig, TransportProxPenalty,
+pointsource_sliding_fb, SlidingFBConfig, TransportConfig, TransportProxPenalty,
 };
 use crate::sliding_pdps::{
 pointsource_sliding_fb_pair_dom, pointsource_sliding_pdps_pair_dom, SlidingPDPSConfig,
 };
 use crate::subproblem::{InnerMethod, InnerSettings};
 fitness_merging: cli.fitness_merging.unwrap_or(g.fitness_merging),
 inner: override_inner(g.inner),
 extra_weight_optimisation_steps: cli
 .extra_weight_optimisation_steps
 .unwrap_or(g.extra_weight_optimisation_steps),
+random_insertions: cli.random_insertions.unwrap_or(g.random_insertions),
 tolerance: cli
 .tolerance
 .as_ref()
 .map(unpack_tolerance)
 .unwrap_or(g.tolerance),
 /// `cont` gives a continuation attempt to find the algorithm matching the description `alg`.
 pub fn run_fb<F, Dat, Reg, P, I, Plot, const N: usize>(
 f: &Dat,
 reg: &Reg,
 prox_penalty: &P,
-init: (
+init: (&AlgorithmConfig<F>, I, Plot, Option<RNDM<N, F>>, String),
-&AlgorithmConfig<F>,
-I,
-Plot,
-Option<RNDM<N, F>>,
-String,
-),
 cont: impl FnOnce(
 (&AlgorithmConfig<F>, I, Plot, Option<RNDM<N, F>>, String),
 ) -> DynResult<RNDM<N, F>>,
 ) -> DynResult<RNDM<N, F>>
 where
 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>>,
 {
-run_fb_dom(f, reg, prox_penalty, init, None, cont)
+run_fb_dom(f, reg, prox_penalty, init, &mut FullSpace, cont)
 }
 /// Runs FB-style algorithms if `alg` so requests and `prox_penalty` matches.
 ///
 /// `cont` gives a continuation attempt to find the algorithm matching the description `alg`.
 I,
 Plot,
 Option<RNDM<N, F>>,
 String,
 ),
-domain: Option<&P::Dom>,
+domain: &mut impl AdmissibleDomain<Loc<N, F>>,
 cont: impl FnOnce(
 (&AlgorithmConfig<F>, I, Plot, Option<RNDM<N, F>>, String),
 ) -> DynResult<RNDM<N, F>>,
 ) -> DynResult<RNDM<N, F>>
 where
 let pt = P::prox_type();
 match alg {
 &AlgorithmConfig::FB(ref algconfig, prox_type) if prox_type == pt => {
 print!("{running}");
-pointsource_fb_reg(f, reg, prox_penalty, algconfig, iterator, plotter, μ0)
+pointsource_fb_dom(
+f,
+reg,
+prox_penalty,
+algconfig,
+iterator,
+plotter,
+μ0,
+domain,
+)
 }
 &AlgorithmConfig::FISTA(ref algconfig, prox_type) if prox_type == pt => {
 print!("{running}");
 pointsource_fista_reg(f, reg, prox_penalty, algconfig, iterator, plotter, μ0)
 }
 &AlgorithmConfig::SlidingFB(ref algconfig, prox_type) if prox_type == pt => {
 print!("{running}");
-pointsource_sliding_fb_dom(f, reg, prox_penalty, algconfig, iterator, plotter, μ0, domain)
+pointsource_sliding_fb(
+f,
+reg,
+prox_penalty,
+algconfig,
+iterator,
+plotter,
+μ0,
+domain,
+)
 }
 _ => cont((alg, iterator, plotter, μ0, running)),
 }
 }
 algorithms,
 make_plotter,
 save_extra,
 (μ0, z, y),
 |p| {
-run_pdps_pair_dom(&f, &reg, &RadonSquared, &opKz, &fnR, &fnH, p, None, |q| {
+run_pdps_pair_dom(
-run_pdps_pair_dom(&f, &reg, &op𝒟, &opKz, &fnR, &fnH, q, None, |_| {
+&f,
-Err(NotImplemented.into())
+&reg,
-})
+&RadonSquared,
-})
+&opKz,
+&fnR,
+&fnH,
+p,
+&mut FullSpace,
+|q| {
+run_pdps_pair_dom(
+&f,
+&reg,
+&op𝒟,
+&opKz,
+&fnR,
+&fnH,
+q,
+&mut FullSpace,
+|_| Err(NotImplemented.into()),
+)
+},
+)
 .map(|Pair(μ, z)| (μ, z))
 },
 )
 }
 (DataTermType::L222, Regularisation::NonnegRadon(α)) => {
 algorithms,
 make_plotter,
 save_extra,
 (μ0, z, y),
 |p| {
-run_pdps_pair_dom(&f, &reg, &RadonSquared, &opKz, &fnR, &fnH, p, None, |q| {
+run_pdps_pair_dom(
-run_pdps_pair_dom(&f, &reg, &op𝒟, &opKz, &fnR, &fnH, q, None, |_| {
+&f,
-Err(NotImplemented.into())
+&reg,
-})
+&RadonSquared,
-})
+&opKz,
+&fnR,
+&fnH,
+p,
+&mut FullSpace,
+|q| {
+run_pdps_pair_dom(
+&f,
+&reg,
+&op𝒟,
+&opKz,
+&fnR,
+&fnH,
+q,
+&mut FullSpace,
+|_| Err(NotImplemented.into()),
+)
+},
+)
 .map(|Pair(μ, z)| (μ, z))
 },
 )
 }
 _ => Err(NotImplemented.into()),
 R: Prox<Z, Codomain = F>,
 H: Conjugable<Y, F, Codomain = F>,
 for<'b> H::Conjugate<'b>: Prox<Y>,
 Plot: Plotter<P::ReturnMapping, S, RNDM<N, F>>,
 {
-run_pdps_pair_dom(f, reg, prox_penalty, opKz, fnR, fnH, init, None, cont)
+run_pdps_pair_dom(
+f,
+reg,
+prox_penalty,
+opKz,
+fnR,
+fnH,
+init,
+&mut FullSpace,
+cont,
+)
 }
 pub fn run_pdps_pair_dom<F, S, Dat, Reg, Z, R, Y, KOpZ, H, P, I, Plot, const N: usize>(
 f: &Dat,
 reg: &Reg,
 I,
 Plot,
 (Option<RNDM<N, F>>, Z, Y),
 String,
 ),
-domain: Option<&P::Dom>,
+domain: &mut impl AdmissibleDomain<Loc<N, F>>,
 cont: impl FnOnce(
 (
 &AlgorithmConfig<F>,
 I,
 Plot,
 let pt = P::prox_type();
 match alg {
 &AlgorithmConfig::ForwardPDPS(ref algconfig, prox_type) if prox_type == pt => {
 print!("{running}");
-pointsource_forward_pdps_pair(
+pointsource_forward_pdps_pair_dom(
 f,
 reg,
 prox_penalty,
 algconfig,
 iterator,
 plotter,
 μ0zy,
 opKz,
 fnR,
 fnH,
+domain,
 )
 }
 &AlgorithmConfig::SlidingPDPS(ref algconfig, prox_type) if prox_type == pt => {
 print!("{running}");
 pointsource_sliding_pdps_pair_dom(
 R: Prox<Z, Codomain = F>,
 Plot: Plotter<P::ReturnMapping, S, RNDM<N, F>>,
 // We should not need to explicitly require this:
 for<'b> &'b Loc<0, F>: Instance<Loc<0, F>>,
 {
-run_fb_pair_dom(f, reg, prox_penalty, fnR, init, None, cont)
+run_fb_pair_dom(f, reg, prox_penalty, fnR, init, &mut FullSpace, cont)
 }
 pub fn run_fb_pair_dom<F, S, Dat, Reg, Z, R, P, I, Plot, const N: usize>(
 f: &Dat,
 reg: &Reg,
 I,
 Plot,
 (Option<RNDM<N, F>>, Z),
 String,
 ),
-domain: Option<&P::Dom>,
+domain: &mut impl AdmissibleDomain<Loc<N, F>>,
 cont: impl FnOnce(
 (
 &AlgorithmConfig<F>,
 I,
 Plot,
 let pt = P::prox_type();
 match alg {
 &AlgorithmConfig::FB(ref algconfig, prox_type) if prox_type == pt => {
 print!("{running}");
-pointsource_fb_pair(f, reg, prox_penalty, algconfig, iterator, plotter, μ0z, fnR)
+pointsource_fb_pair_dom(
+f,
+reg,
+prox_penalty,
+algconfig,
+iterator,
+plotter,
+μ0z,
+fnR,
+domain,
+)
 }
 &AlgorithmConfig::SlidingFB(ref algconfig, prox_type) if prox_type == pt => {
 print!("{running}");
 pointsource_sliding_fb_pair_dom(
 f,
 algconfig,
 iterator,
 plotter,
 μ0z,
 fnR,
-domain
+domain,
 )
 }
 _ => cont((alg, iterator, plotter, μ0z, running)),
 }
 }

Mercurial > repos > pointsource_algs / file comparison

comparison: src/run.rs

src/run.rs