--- a/src/run.rs Mon Jan 06 11:32:57 2025 -0500
+++ b/src/run.rs Thu Jan 23 23:35:28 2025 +0100
@@ -72,11 +72,6 @@
pointsource_fb_reg,
pointsource_fista_reg,
};
-use crate::radon_fb::{
- RadonFBConfig,
- pointsource_radon_fb_reg,
- pointsource_radon_fista_reg,
-};
use crate::sliding_fb::{
SlidingFBConfig,
TransportConfig,
@@ -114,22 +109,33 @@
L1,
L2Squared,
};
+use crate::prox_penalty::{
+ RadonSquared,
+ //ProxPenalty,
+};
use alg_tools::norms::{L2, NormExponent};
use alg_tools::operator_arithmetic::Weighted;
use anyhow::anyhow;
+/// Available proximal terms
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+pub enum ProxTerm {
+ /// Partial-to-wave operator 𝒟.
+ Wave,
+ /// Radon-norm squared
+ RadonSquared
+}
+
/// Available algorithms and their configurations
#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
pub enum AlgorithmConfig<F : Float> {
- FB(FBConfig<F>),
- FISTA(FBConfig<F>),
+ FB(FBConfig<F>, ProxTerm),
+ FISTA(FBConfig<F>, ProxTerm),
FW(FWConfig<F>),
- PDPS(PDPSConfig<F>),
- RadonFB(RadonFBConfig<F>),
- RadonFISTA(RadonFBConfig<F>),
- SlidingFB(SlidingFBConfig<F>),
- ForwardPDPS(ForwardPDPSConfig<F>),
- SlidingPDPS(SlidingPDPSConfig<F>),
+ PDPS(PDPSConfig<F>, ProxTerm),
+ SlidingFB(SlidingFBConfig<F>, ProxTerm),
+ ForwardPDPS(ForwardPDPSConfig<F>, ProxTerm),
+ SlidingPDPS(SlidingPDPSConfig<F>, ProxTerm),
}
fn unpack_tolerance<F : Float>(v : &Vec<F>) -> Tolerance<F> {
@@ -165,45 +171,35 @@
use AlgorithmConfig::*;
match self {
- FB(fb) => FB(FBConfig {
+ FB(fb, prox) => FB(FBConfig {
τ0 : cli.tau0.unwrap_or(fb.τ0),
generic : override_fb_generic(fb.generic),
.. fb
- }),
- FISTA(fb) => FISTA(FBConfig {
+ }, prox),
+ FISTA(fb, prox) => FISTA(FBConfig {
τ0 : cli.tau0.unwrap_or(fb.τ0),
generic : override_fb_generic(fb.generic),
.. fb
- }),
- PDPS(pdps) => PDPS(PDPSConfig {
+ }, prox),
+ PDPS(pdps, prox) => PDPS(PDPSConfig {
τ0 : cli.tau0.unwrap_or(pdps.τ0),
σ0 : cli.sigma0.unwrap_or(pdps.σ0),
acceleration : cli.acceleration.unwrap_or(pdps.acceleration),
generic : override_fb_generic(pdps.generic),
.. pdps
- }),
+ }, prox),
FW(fw) => FW(FWConfig {
merging : cli.merging.clone().unwrap_or(fw.merging),
tolerance : cli.tolerance.as_ref().map(unpack_tolerance).unwrap_or(fw.tolerance),
.. fw
}),
- RadonFB(fb) => RadonFB(RadonFBConfig {
- τ0 : cli.tau0.unwrap_or(fb.τ0),
- insertion : override_fb_generic(fb.insertion),
- .. fb
- }),
- RadonFISTA(fb) => RadonFISTA(RadonFBConfig {
- τ0 : cli.tau0.unwrap_or(fb.τ0),
- insertion : override_fb_generic(fb.insertion),
- .. fb
- }),
- SlidingFB(sfb) => SlidingFB(SlidingFBConfig {
+ SlidingFB(sfb, prox) => SlidingFB(SlidingFBConfig {
τ0 : cli.tau0.unwrap_or(sfb.τ0),
transport : override_transport(sfb.transport),
insertion : override_fb_generic(sfb.insertion),
.. sfb
- }),
- SlidingPDPS(spdps) => SlidingPDPS(SlidingPDPSConfig {
+ }, prox),
+ SlidingPDPS(spdps, prox) => SlidingPDPS(SlidingPDPSConfig {
τ0 : cli.tau0.unwrap_or(spdps.τ0),
σp0 : cli.sigmap0.unwrap_or(spdps.σp0),
σd0 : cli.sigma0.unwrap_or(spdps.σd0),
@@ -211,15 +207,15 @@
transport : override_transport(spdps.transport),
insertion : override_fb_generic(spdps.insertion),
.. spdps
- }),
- ForwardPDPS(fpdps) => ForwardPDPS(ForwardPDPSConfig {
+ }, prox),
+ ForwardPDPS(fpdps, prox) => ForwardPDPS(ForwardPDPSConfig {
τ0 : cli.tau0.unwrap_or(fpdps.τ0),
σp0 : cli.sigmap0.unwrap_or(fpdps.σp0),
σd0 : cli.sigma0.unwrap_or(fpdps.σd0),
//acceleration : cli.acceleration.unwrap_or(pdps.acceleration),
insertion : override_fb_generic(fpdps.insertion),
.. fpdps
- }),
+ }, prox),
}
}
}
@@ -250,12 +246,6 @@
/// The μPDPS primal-dual proximal splitting method
#[clap(name = "pdps")]
PDPS,
- /// The RadonFB forward-backward method
- #[clap(name = "radon_fb")]
- RadonFB,
- /// The RadonFISTA inertial forward-backward method
- #[clap(name = "radon_fista")]
- RadonFISTA,
/// The sliding FB method
#[clap(name = "sliding_fb", alias = "sfb")]
SlidingFB,
@@ -265,6 +255,27 @@
/// The PDPS method with a forward step for the smooth function
#[clap(name = "forward_pdps", alias = "fpdps")]
ForwardPDPS,
+
+ // Radon variants
+
+ /// The μFB forward-backward method with radon-norm squared proximal term
+ #[clap(name = "radon_fb")]
+ RadonFB,
+ /// The μFISTA inertial forward-backward method with radon-norm squared proximal term
+ #[clap(name = "radon_fista")]
+ RadonFISTA,
+ /// The μPDPS primal-dual proximal splitting method with radon-norm squared proximal term
+ #[clap(name = "radon_pdps")]
+ RadonPDPS,
+ /// The sliding FB method with radon-norm squared proximal term
+ #[clap(name = "radon_sliding_fb", alias = "radon_sfb")]
+ RadonSlidingFB,
+ /// The sliding PDPS method with radon-norm squared proximal term
+ #[clap(name = "radon_sliding_pdps", alias = "radon_spdps")]
+ RadonSlidingPDPS,
+ /// The PDPS method with a forward step for the smooth function with radon-norm squared proximal term
+ #[clap(name = "radon_forward_pdps", alias = "radon_fpdps")]
+ RadonForwardPDPS,
}
impl DefaultAlgorithm {
@@ -272,19 +283,26 @@
pub fn default_config<F : Float>(&self) -> AlgorithmConfig<F> {
use DefaultAlgorithm::*;
match *self {
- FB => AlgorithmConfig::FB(Default::default()),
- FISTA => AlgorithmConfig::FISTA(Default::default()),
+ FB => AlgorithmConfig::FB(Default::default(), ProxTerm::Wave),
+ FISTA => AlgorithmConfig::FISTA(Default::default(), ProxTerm::Wave),
FW => AlgorithmConfig::FW(Default::default()),
FWRelax => AlgorithmConfig::FW(FWConfig{
variant : FWVariant::Relaxed,
.. Default::default()
}),
- PDPS => AlgorithmConfig::PDPS(Default::default()),
- RadonFB => AlgorithmConfig::RadonFB(Default::default()),
- RadonFISTA => AlgorithmConfig::RadonFISTA(Default::default()),
- SlidingFB => AlgorithmConfig::SlidingFB(Default::default()),
- SlidingPDPS => AlgorithmConfig::SlidingPDPS(Default::default()),
- ForwardPDPS => AlgorithmConfig::ForwardPDPS(Default::default()),
+ PDPS => AlgorithmConfig::PDPS(Default::default(), ProxTerm::Wave),
+ SlidingFB => AlgorithmConfig::SlidingFB(Default::default(), ProxTerm::Wave),
+ SlidingPDPS => AlgorithmConfig::SlidingPDPS(Default::default(), ProxTerm::Wave),
+ ForwardPDPS => AlgorithmConfig::ForwardPDPS(Default::default(), ProxTerm::Wave),
+
+ // Radon variants
+
+ RadonFB => AlgorithmConfig::FB(Default::default(), ProxTerm::RadonSquared),
+ RadonFISTA => AlgorithmConfig::FISTA(Default::default(), ProxTerm::RadonSquared),
+ RadonPDPS => AlgorithmConfig::PDPS(Default::default(), ProxTerm::RadonSquared),
+ RadonSlidingFB => AlgorithmConfig::SlidingFB(Default::default(), ProxTerm::RadonSquared),
+ RadonSlidingPDPS => AlgorithmConfig::SlidingPDPS(Default::default(), ProxTerm::RadonSquared),
+ RadonForwardPDPS => AlgorithmConfig::ForwardPDPS(Default::default(), ProxTerm::RadonSquared),
}
}
@@ -602,7 +620,7 @@
}
#[replace_float_literals(F::cast_from(literal))]
-impl<F, NoiseDistr, S, K, P, const N : usize> RunnableExperiment<F> for
+impl<F, NoiseDistr, S, K, P, /*PreadjointCodomain, */ const N : usize> RunnableExperiment<F> for
Named<ExperimentV2<F, NoiseDistr, S, K, P, N>>
where
F : ClapFloat + nalgebra::RealField + ToNalgebraRealField<MixedType=F>,
@@ -628,7 +646,13 @@
DefaultBT<F, N> : SensorGridBT<F, S, P, N, Depth=DynamicDepth> + BTSearch<F, N>,
BTNodeLookup: BTNode<F, usize, Bounds<F>, N>,
RNDM<F, N> : SpikeMerging<F>,
- NoiseDistr : Distribution<F> + Serialize + std::fmt::Debug
+ NoiseDistr : Distribution<F> + Serialize + std::fmt::Debug,
+ // DefaultSG<F, S, P, N> : ForwardModel<RNDM<F, N>, F, PreadjointCodomain = PreadjointCodomain, Observable=DVector<F::MixedType>>,
+ // PreadjointCodomain : Space + Bounded<F> + DifferentiableRealMapping<F, N>,
+ // DefaultSeminormOp<F, K, N> : ProxPenalty<F, PreadjointCodomain, RadonRegTerm<F>, N>,
+ // DefaultSeminormOp<F, K, N> : ProxPenalty<F, PreadjointCodomain, NonnegRadonRegTerm<F>, N>,
+ // RadonSquared : ProxPenalty<F, PreadjointCodomain, RadonRegTerm<F>, N>,
+ // RadonSquared : ProxPenalty<F, PreadjointCodomain, NonnegRadonRegTerm<F>, N>,
{
fn algorithm_defaults(&self, alg : DefaultAlgorithm) -> Option<AlgorithmConfig<F>> {
@@ -663,7 +687,7 @@
let mut rng = StdRng::seed_from_u64(noise_seed);
// Generate the data and calculate SSNR statistic
- let b_hat : DVector<_> = opA.apply(μ_hat);
+ let b_hat = opA.apply(μ_hat);
let noise = DVector::from_distribution(b_hat.len(), &noise_distr, &mut rng);
let b = &b_hat + &noise;
// Need to wrap calc_ssnr into a function to hide ultra-lame nalgebra::RealField
@@ -683,128 +707,157 @@
|alg, iterator, plotter, running|
{
let μ = match alg {
- AlgorithmConfig::FB(ref algconfig) => {
- match (regularisation, dataterm) {
- (Regularisation::NonnegRadon(α), DataTerm::L2Squared) => Ok({
+ AlgorithmConfig::FB(ref algconfig, prox) => {
+ match (regularisation, dataterm, prox) {
+ (Regularisation::NonnegRadon(α), DataTerm::L2Squared, ProxTerm::Wave) => Ok({
print!("{running}");
pointsource_fb_reg(
&opA, &b, NonnegRadonRegTerm(α), &op𝒟, algconfig,
iterator, plotter
)
}),
- (Regularisation::Radon(α), DataTerm::L2Squared) => Ok({
+ (Regularisation::Radon(α), DataTerm::L2Squared, ProxTerm::Wave) => Ok({
print!("{running}");
pointsource_fb_reg(
&opA, &b, RadonRegTerm(α), &op𝒟, algconfig,
iterator, plotter
)
}),
+ (Regularisation::NonnegRadon(α), DataTerm::L2Squared, ProxTerm::RadonSquared) => Ok({
+ print!("{running}");
+ pointsource_fb_reg(
+ &opA, &b, NonnegRadonRegTerm(α), &RadonSquared, algconfig,
+ iterator, plotter
+ )
+ }),
+ (Regularisation::Radon(α), DataTerm::L2Squared, ProxTerm::RadonSquared) => Ok({
+ print!("{running}");
+ pointsource_fb_reg(
+ &opA, &b, RadonRegTerm(α), &RadonSquared, algconfig,
+ iterator, plotter
+ )
+ }),
_ => Err(NotImplemented)
}
},
- AlgorithmConfig::FISTA(ref algconfig) => {
- match (regularisation, dataterm) {
- (Regularisation::NonnegRadon(α), DataTerm::L2Squared) => Ok({
+ AlgorithmConfig::FISTA(ref algconfig, prox) => {
+ match (regularisation, dataterm, prox) {
+ (Regularisation::NonnegRadon(α), DataTerm::L2Squared, ProxTerm::Wave) => Ok({
print!("{running}");
pointsource_fista_reg(
&opA, &b, NonnegRadonRegTerm(α), &op𝒟, algconfig,
iterator, plotter
)
}),
- (Regularisation::Radon(α), DataTerm::L2Squared) => Ok({
+ (Regularisation::Radon(α), DataTerm::L2Squared, ProxTerm::Wave) => Ok({
print!("{running}");
pointsource_fista_reg(
&opA, &b, RadonRegTerm(α), &op𝒟, algconfig,
iterator, plotter
)
}),
- _ => Err(NotImplemented),
- }
- },
- AlgorithmConfig::RadonFB(ref algconfig) => {
- match (regularisation, dataterm) {
- (Regularisation::NonnegRadon(α), DataTerm::L2Squared) => Ok({
+ (Regularisation::NonnegRadon(α), DataTerm::L2Squared, ProxTerm::RadonSquared) => Ok({
print!("{running}");
- pointsource_radon_fb_reg(
- &opA, &b, NonnegRadonRegTerm(α), algconfig,
+ pointsource_fista_reg(
+ &opA, &b, NonnegRadonRegTerm(α), &RadonSquared, algconfig,
iterator, plotter
)
}),
- (Regularisation::Radon(α), DataTerm::L2Squared) => Ok({
+ (Regularisation::Radon(α), DataTerm::L2Squared, ProxTerm::RadonSquared) => Ok({
print!("{running}");
- pointsource_radon_fb_reg(
- &opA, &b, RadonRegTerm(α), algconfig,
+ pointsource_fista_reg(
+ &opA, &b, RadonRegTerm(α), &RadonSquared, algconfig,
iterator, plotter
)
}),
_ => Err(NotImplemented),
}
},
- AlgorithmConfig::RadonFISTA(ref algconfig) => {
- match (regularisation, dataterm) {
- (Regularisation::NonnegRadon(α), DataTerm::L2Squared) => Ok({
- print!("{running}");
- pointsource_radon_fista_reg(
- &opA, &b, NonnegRadonRegTerm(α), algconfig,
- iterator, plotter
- )
- }),
- (Regularisation::Radon(α), DataTerm::L2Squared) => Ok({
- print!("{running}");
- pointsource_radon_fista_reg(
- &opA, &b, RadonRegTerm(α), algconfig,
- iterator, plotter
- )
- }),
- _ => Err(NotImplemented),
- }
- },
- AlgorithmConfig::SlidingFB(ref algconfig) => {
- match (regularisation, dataterm) {
- (Regularisation::NonnegRadon(α), DataTerm::L2Squared) => Ok({
+ AlgorithmConfig::SlidingFB(ref algconfig, prox) => {
+ match (regularisation, dataterm, prox) {
+ (Regularisation::NonnegRadon(α), DataTerm::L2Squared, ProxTerm::Wave) => Ok({
print!("{running}");
pointsource_sliding_fb_reg(
&opA, &b, NonnegRadonRegTerm(α), &op𝒟, algconfig,
iterator, plotter
)
}),
- (Regularisation::Radon(α), DataTerm::L2Squared) => Ok({
+ (Regularisation::Radon(α), DataTerm::L2Squared, ProxTerm::Wave) => Ok({
print!("{running}");
pointsource_sliding_fb_reg(
&opA, &b, RadonRegTerm(α), &op𝒟, algconfig,
iterator, plotter
)
}),
+ (Regularisation::NonnegRadon(α), DataTerm::L2Squared, ProxTerm::RadonSquared) => Ok({
+ print!("{running}");
+ pointsource_sliding_fb_reg(
+ &opA, &b, NonnegRadonRegTerm(α), &RadonSquared, algconfig,
+ iterator, plotter
+ )
+ }),
+ (Regularisation::Radon(α), DataTerm::L2Squared, ProxTerm::RadonSquared) => Ok({
+ print!("{running}");
+ pointsource_sliding_fb_reg(
+ &opA, &b, RadonRegTerm(α), &RadonSquared, algconfig,
+ iterator, plotter
+ )
+ }),
_ => Err(NotImplemented),
}
},
- AlgorithmConfig::PDPS(ref algconfig) => {
+ AlgorithmConfig::PDPS(ref algconfig, prox) => {
print!("{running}");
- match (regularisation, dataterm) {
- (Regularisation::NonnegRadon(α), DataTerm::L2Squared) => Ok({
+ match (regularisation, dataterm, prox) {
+ (Regularisation::NonnegRadon(α), DataTerm::L2Squared, ProxTerm::Wave) => Ok({
pointsource_pdps_reg(
&opA, &b, NonnegRadonRegTerm(α), &op𝒟, algconfig,
iterator, plotter, L2Squared
)
}),
- (Regularisation::Radon(α),DataTerm::L2Squared) => Ok({
+ (Regularisation::Radon(α),DataTerm::L2Squared, ProxTerm::Wave) => Ok({
pointsource_pdps_reg(
&opA, &b, RadonRegTerm(α), &op𝒟, algconfig,
iterator, plotter, L2Squared
)
}),
- (Regularisation::NonnegRadon(α), DataTerm::L1) => Ok({
+ (Regularisation::NonnegRadon(α), DataTerm::L1, ProxTerm::Wave) => Ok({
pointsource_pdps_reg(
&opA, &b, NonnegRadonRegTerm(α), &op𝒟, algconfig,
iterator, plotter, L1
)
}),
- (Regularisation::Radon(α), DataTerm::L1) => Ok({
+ (Regularisation::Radon(α), DataTerm::L1, ProxTerm::Wave) => Ok({
pointsource_pdps_reg(
&opA, &b, RadonRegTerm(α), &op𝒟, algconfig,
iterator, plotter, L1
)
}),
+ (Regularisation::NonnegRadon(α), DataTerm::L2Squared, ProxTerm::RadonSquared) => Ok({
+ pointsource_pdps_reg(
+ &opA, &b, NonnegRadonRegTerm(α), &RadonSquared, algconfig,
+ iterator, plotter, L2Squared
+ )
+ }),
+ (Regularisation::Radon(α),DataTerm::L2Squared, ProxTerm::RadonSquared) => Ok({
+ pointsource_pdps_reg(
+ &opA, &b, RadonRegTerm(α), &RadonSquared, algconfig,
+ iterator, plotter, L2Squared
+ )
+ }),
+ (Regularisation::NonnegRadon(α), DataTerm::L1, ProxTerm::RadonSquared) => Ok({
+ pointsource_pdps_reg(
+ &opA, &b, NonnegRadonRegTerm(α), &RadonSquared, algconfig,
+ iterator, plotter, L1
+ )
+ }),
+ (Regularisation::Radon(α), DataTerm::L1, ProxTerm::RadonSquared) => Ok({
+ pointsource_pdps_reg(
+ &opA, &b, RadonRegTerm(α), &RadonSquared, algconfig,
+ iterator, plotter, L1
+ )
+ }),
+ // _ => Err(NotImplemented),
}
},
AlgorithmConfig::FW(ref algconfig) => {
@@ -831,7 +884,7 @@
#[replace_float_literals(F::cast_from(literal))]
-impl<F, NoiseDistr, S, K, P, B, const N : usize> RunnableExperiment<F> for
+impl<F, NoiseDistr, S, K, P, B, /*PreadjointCodomain,*/ const N : usize> RunnableExperiment<F> for
Named<ExperimentBiased<F, NoiseDistr, S, K, P, B, N>>
where
F : ClapFloat + nalgebra::RealField + ToNalgebraRealField<MixedType=F>,
@@ -859,6 +912,12 @@
RNDM<F, N> : SpikeMerging<F>,
NoiseDistr : Distribution<F> + Serialize + std::fmt::Debug,
B : Mapping<Loc<F, N>, Codomain = F> + Serialize + std::fmt::Debug,
+ // DefaultSG<F, S, P, N> : ForwardModel<RNDM<F, N>, F, PreadjointCodomain = PreadjointCodomain, Observable=DVector<F::MixedType>>,
+ // PreadjointCodomain : Bounded<F> + DifferentiableRealMapping<F, N>,
+ // DefaultSeminormOp<F, K, N> : ProxPenalty<F, PreadjointCodomain, RadonRegTerm<F>, N>,
+ // DefaultSeminormOp<F, K, N> : ProxPenalty<F, PreadjointCodomain, NonnegRadonRegTerm<F>, N>,
+ // RadonSquared : ProxPenalty<F, PreadjointCodomain, RadonRegTerm<F>, N>,
+ // RadonSquared : ProxPenalty<F, PreadjointCodomain, NonnegRadonRegTerm<F>, N>,
{
fn algorithm_defaults(&self, alg : DefaultAlgorithm) -> Option<AlgorithmConfig<F>> {
@@ -937,9 +996,9 @@
|alg, iterator, plotter, running|
{
let Pair(μ, z) = match alg {
- AlgorithmConfig::ForwardPDPS(ref algconfig) => {
- match (regularisation, dataterm) {
- (Regularisation::NonnegRadon(α), DataTerm::L2Squared) => Ok({
+ AlgorithmConfig::ForwardPDPS(ref algconfig, prox) => {
+ match (regularisation, dataterm, prox) {
+ (Regularisation::NonnegRadon(α), DataTerm::L2Squared, ProxTerm::Wave) => Ok({
print!("{running}");
pointsource_forward_pdps_pair(
&opAext, &b, NonnegRadonRegTerm(α), &op𝒟, algconfig,
@@ -947,7 +1006,7 @@
/* opKμ, */ &opKz, &fnR, &fnH, z.clone(), y.clone(),
)
}),
- (Regularisation::Radon(α), DataTerm::L2Squared) => Ok({
+ (Regularisation::Radon(α), DataTerm::L2Squared, ProxTerm::Wave) => Ok({
print!("{running}");
pointsource_forward_pdps_pair(
&opAext, &b, RadonRegTerm(α), &op𝒟, algconfig,
@@ -955,12 +1014,28 @@
/* opKμ, */ &opKz, &fnR, &fnH, z.clone(), y.clone(),
)
}),
+ (Regularisation::NonnegRadon(α), DataTerm::L2Squared, ProxTerm::RadonSquared) => Ok({
+ print!("{running}");
+ pointsource_forward_pdps_pair(
+ &opAext, &b, NonnegRadonRegTerm(α), &RadonSquared, algconfig,
+ iterator, plotter,
+ /* opKμ, */ &opKz, &fnR, &fnH, z.clone(), y.clone(),
+ )
+ }),
+ (Regularisation::Radon(α), DataTerm::L2Squared, ProxTerm::RadonSquared) => Ok({
+ print!("{running}");
+ pointsource_forward_pdps_pair(
+ &opAext, &b, RadonRegTerm(α), &RadonSquared, algconfig,
+ iterator, plotter,
+ /* opKμ, */ &opKz, &fnR, &fnH, z.clone(), y.clone(),
+ )
+ }),
_ => Err(NotImplemented)
}
},
- AlgorithmConfig::SlidingPDPS(ref algconfig) => {
- match (regularisation, dataterm) {
- (Regularisation::NonnegRadon(α), DataTerm::L2Squared) => Ok({
+ AlgorithmConfig::SlidingPDPS(ref algconfig, prox) => {
+ match (regularisation, dataterm, prox) {
+ (Regularisation::NonnegRadon(α), DataTerm::L2Squared, ProxTerm::Wave) => Ok({
print!("{running}");
pointsource_sliding_pdps_pair(
&opAext, &b, NonnegRadonRegTerm(α), &op𝒟, algconfig,
@@ -968,7 +1043,7 @@
/* opKμ, */ &opKz, &fnR, &fnH, z.clone(), y.clone(),
)
}),
- (Regularisation::Radon(α), DataTerm::L2Squared) => Ok({
+ (Regularisation::Radon(α), DataTerm::L2Squared, ProxTerm::Wave) => Ok({
print!("{running}");
pointsource_sliding_pdps_pair(
&opAext, &b, RadonRegTerm(α), &op𝒟, algconfig,
@@ -976,6 +1051,22 @@
/* opKμ, */ &opKz, &fnR, &fnH, z.clone(), y.clone(),
)
}),
+ (Regularisation::NonnegRadon(α), DataTerm::L2Squared, ProxTerm::RadonSquared) => Ok({
+ print!("{running}");
+ pointsource_sliding_pdps_pair(
+ &opAext, &b, NonnegRadonRegTerm(α), &RadonSquared, algconfig,
+ iterator, plotter,
+ /* opKμ, */ &opKz, &fnR, &fnH, z.clone(), y.clone(),
+ )
+ }),
+ (Regularisation::Radon(α), DataTerm::L2Squared, ProxTerm::RadonSquared) => Ok({
+ print!("{running}");
+ pointsource_sliding_pdps_pair(
+ &opAext, &b, RadonRegTerm(α), &RadonSquared, algconfig,
+ iterator, plotter,
+ /* opKμ, */ &opKz, &fnR, &fnH, z.clone(), y.clone(),
+ )
+ }),
_ => Err(NotImplemented)
}
},