pointsource_algs: comparison src/experiments.rs

-:9738b51d90d7
+:4f468d35fa29
 /*!
 Experimental setups.
 */
 //use numeric_literals::replace_float_literals;
-use serde::{Serialize, Deserialize};
+use crate::kernels::SupportProductFirst as Prod;
-use clap::ValueEnum;
+use crate::kernels::*;
-use std::collections::HashMap;
+use crate::run::{DefaultAlgorithm, ExperimentBiased, ExperimentV2, Named, RunnableExperiment};
-use std::hash::{Hash, Hasher};
+use crate::types::*;
-use std::collections::hash_map::DefaultHasher;
+use crate::{AlgorithmOverrides, ExperimentSetup};
 use alg_tools::bisection_tree::*;
 use alg_tools::error::DynResult;
 use alg_tools::norms::Linfinity;
+use clap::{Parser, ValueEnum};
-use crate::{ExperimentOverrides, AlgorithmOverrides};
+use serde::{Deserialize, Serialize};
-use crate::kernels::*;
+use std::collections::hash_map::DefaultHasher;
-use crate::kernels::SupportProductFirst as Prod;
+use std::collections::HashMap;
-use crate::types::*;
+use std::hash::{Hash, Hasher};
-use crate::run::{
+//use crate::fb::InsertionConfig;
-RunnableExperiment,
+use crate::rand_distr::{SaltAndPepper, SerializableNormal};
-ExperimentV2,
-ExperimentBiased,
-Named,
-DefaultAlgorithm,
-};
-//use crate::fb::FBGenericConfig;
-use crate::rand_distr::{SerializableNormal, SaltAndPepper};
 use crate::regularisation::Regularisation;
 use alg_tools::euclidean::Euclidean;
 use alg_tools::instance::Instance;
 use alg_tools::mapping::Mapping;
 use alg_tools::operator_arithmetic::{MappingSum, Weighted};
+use itertools::Itertools;
+use serde_with::skip_serializing_none;
 /// Experiments shorthands, to be used with the command line parser
 #[derive(ValueEnum, Debug, Copy, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
 #[allow(non_camel_case_types)]
 pub enum DefaultExperiment {
 /// One dimension, cut gaussian spread, 2-norm-squared data fidelity
 #[clap(name = "1d")]
 /// Two dimensions, “fast” spread, 2-norm-squared data fidelity with extra TV-regularised bias
 #[clap(name = "2d_tv_fast")]
 Experiment2D_TV_Fast,
 }
+/// Command line experiment setup overrides
+#[skip_serializing_none]
+#[derive(Parser, Debug, Serialize, Deserialize, Default, Clone, Hash)]
+pub struct DefaultExperimentSetup<F: ClapFloat> {
+/// List of experiments to perform
+#[arg(value_name = "EXPERIMENT")]
+experiments: Vec<DefaultExperiment>,
+#[arg(long)]
+/// Regularisation parameter override.
+///
+/// Only use if running just a single experiment, as different experiments have different
+/// regularisation parameters.
+alpha: Option<F>,
+#[arg(long)]
+/// Gaussian noise variance override
+variance: Option<F>,
+#[arg(long, value_names = &["MAGNITUDE", "PROBABILITY"])]
+/// Salt and pepper noise override.
+salt_and_pepper: Option<Vec<F>>,
+#[arg(long)]
+/// Noise seed
+noise_seed: Option<u64>,
+}
 macro_rules! make_float_constant {
 ($name:ident = $value:expr) => {
 #[derive(Debug, Copy, Eq, PartialEq, Clone, Serialize, Deserialize)]
 #[serde(into = "float")]
 struct $name;
-impl Into<float> for $name {
+impl Into<f64> for $name {
 #[inline]
-fn into(self) -> float { $value }
+fn into(self) -> float {
+$value
+}
 }
 impl Constant for $name {
 type Type = float;
-fn value(&self) -> float { $value }
+fn value(&self) -> float {
+$value
+}
 }
-}
+};
 }
 /// Ground-truth measure spike locations and magnitudes for 1D experiments
-static MU_TRUE_1D_BASIC : [(float, float); 4] = [
+static MU_TRUE_1D_BASIC: [(float, float); 4] =
-(0.10, 10.0),
+[(0.10, 10.0), (0.30, 2.0), (0.70, 3.0), (0.80, 5.0)];
-(0.30, 2.0),
-(0.70, 3.0),
-(0.80, 5.0)
-];
 /// Ground-truth measure spike locations and magnitudes for 2D experiments
-static MU_TRUE_2D_BASIC : [([float; 2], float); 4] = [
+static MU_TRUE_2D_BASIC: [([float; 2], float); 4] = [
 ([0.15, 0.15], 10.0),
 ([0.75, 0.45], 2.0),
 ([0.80, 0.50], 4.0),
-([0.30, 0.70], 5.0)
+([0.30, 0.70], 5.0),
 ];
 /// The $\{0,1\}$-valued characteristic function of a ball as a [`Mapping`].
-#[derive(Debug,Copy,Clone,Serialize,PartialEq)]
+#[derive(Debug, Copy, Clone, Serialize, PartialEq)]
-struct BallCharacteristic<F : Float, const N : usize> {
+struct BallCharacteristic<F: Float, const N: usize> {
-pub center : Loc<F, N>,
+pub center: Loc<N, F>,
-pub radius : F,
+pub radius: F,
 }
-impl<F : Float, const N : usize> Mapping<Loc<F, N>> for BallCharacteristic<F, N> {
+impl<F: Float, const N: usize> Mapping<Loc<N, F>> for BallCharacteristic<F, N> {
-type Codomain =F;
+type Codomain = F;
-fn apply<I : Instance<Loc<F, N>>>(&self, i : I) -> F {
+fn apply<I: Instance<Loc<N, F>>>(&self, i: I) -> F {
 if self.center.dist2(i) <= self.radius {
 F::ONE
 } else {
 F::ZERO
 }
 }
 }
+/// Trait for customising the experiments available from the command line
+impl ExperimentSetup for DefaultExperimentSetup<f64> {
+type FloatType = f64;
+fn runnables(&self) -> DynResult<Vec<Box<dyn RunnableExperiment<Self::FloatType>>>> {
+self.experiments
+.iter()
+.unique()
+.map(|e| e.get_experiment(self))
+.try_collect()
+}
+}
 //#[replace_float_literals(F::cast_from(literal))]
 impl DefaultExperiment {
+// fn default_list() -> Vec<Self> {
+//     use DefaultExperiment::*;
+//     [
+//         Experiment1D,
+//         Experiment1DFast,
+//         Experiment2D,
+//         Experiment2DFast,
+//         Experiment1D_L1,
+//     ]
+//     .into()
+// }
 /// Convert the experiment shorthand into a runnable experiment configuration.
-pub fn get_experiment(&self, cli : &ExperimentOverrides<float>) -> DynResult<Box<dyn RunnableExperiment<float>>> {
+fn get_experiment(
-let name = "pointsource".to_string()
+&self,
-+ self.to_possible_value().unwrap().get_name();
+cli: &DefaultExperimentSetup<f64>,
+) -> DynResult<Box<dyn RunnableExperiment<f64>>> {
+let name = "pointsource".to_string() + self.to_possible_value().unwrap().get_name();
 let kernel_plot_width = 0.2;
-const BASE_SEED : u64 = 915373234;
+const BASE_SEED: u64 = 915373234;
-const N_SENSORS_1D : usize = 100;
+const N_SENSORS_1D: usize = 100;
-make_float_constant!(SensorWidth1D = 0.4/(N_SENSORS_1D as float));
+make_float_constant!(SensorWidth1D = 0.4 / (N_SENSORS_1D as float));
-const N_SENSORS_2D : usize = 16;
+const N_SENSORS_2D: usize = 16;
-make_float_constant!(SensorWidth2D = 0.4/(N_SENSORS_2D as float));
+make_float_constant!(SensorWidth2D = 0.4 / (N_SENSORS_2D as float));
-const N_SENSORS_2D_MORE : usize = 32;
+//const N_SENSORS_2D_MORE: usize = 32;
-make_float_constant!(SensorWidth2DMore = 0.4/(N_SENSORS_2D_MORE as float));
+//make_float_constant!(SensorWidth2DMore = 0.4 / (N_SENSORS_2D_MORE as float));
 make_float_constant!(Variance1 = 0.05.powi(2));
 make_float_constant!(CutOff1 = 0.15);
 make_float_constant!(Hat1 = 0.16);
 make_float_constant!(HatBias = 0.05);
 //         tau0 : Some(3.0),
 //         sigma0 : Some(0.99 / 3.0),
 //         .. Default::default()
 //     }
 // );
-let sliding_fb_cut_gaussian = (DefaultAlgorithm::SlidingFB,
+let sliding_fb_cut_gaussian = (DefaultAlgorithm::SlidingFB, AlgorithmOverrides {
-AlgorithmOverrides {
+theta0: Some(0.3),
-theta0 : Some(0.3),
+..Default::default()
-.. Default::default()
+});
-}
-);
 // let higher_cpos = |alg| (alg,
 //     AlgorithmOverrides {
 //         transport_tolerance_pos : Some(1000.0),
 //         .. Default::default()
 //     }
 // );
-let higher_cpos_merging = |alg| (alg,
+let higher_cpos_merging = |alg| {
-AlgorithmOverrides {
+(alg, AlgorithmOverrides {
-transport_tolerance_pos : Some(1000.0),
+transport_tolerance_pos: Some(1000.0),
-merge : Some(true),
+merge: Some(true),
-fitness_merging : Some(true),
+fitness_merging: Some(true),
-.. Default::default()
+..Default::default()
-}
+})
-);
+};
-let higher_cpos_merging_steptune = |alg| (alg,
+let higher_cpos_merging_steptune = |alg| {
-AlgorithmOverrides {
+(alg, AlgorithmOverrides {
-transport_tolerance_pos : Some(1000.0),
+transport_tolerance_pos: Some(1000.0),
-theta0 : Some(0.3),
+theta0: Some(0.3),
-merge : Some(true),
+merge: Some(true),
-fitness_merging : Some(true),
+fitness_merging: Some(true),
-.. Default::default()
+..Default::default()
-}
+})
-);
+};
-let much_higher_cpos_merging_steptune = |alg| (alg,
+let much_higher_cpos_merging_steptune = |alg| {
-AlgorithmOverrides {
+(alg, AlgorithmOverrides {
-transport_tolerance_pos : Some(10000.0),
+transport_tolerance_pos: Some(10000.0),
-sigma0 : Some(0.15),
+sigma0: Some(0.15),
-theta0 : Some(0.3),
+theta0: Some(0.3),
-merge : Some(true),
+merge: Some(true),
-fitness_merging : Some(true),
+fitness_merging: Some(true),
-.. Default::default()
+..Default::default()
-}
+})
-);
+};
 //  We add a hash of the experiment name to the configured
 // noise seed to not use the same noise for different experiments.
 let mut h = DefaultHasher::new();
 name.hash(&mut h);
 let noise_seed = cli.noise_seed.unwrap_or(BASE_SEED) + h.finish();
 let default_merge_radius = 0.01;
 use DefaultExperiment::*;
 Ok(match self {
 Experiment1D => {
-let base_spread = Gaussian { variance : Variance1 };
+let base_spread = Gaussian { variance: Variance1 };
-let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity };
+let spread_cutoff = BallIndicator { r: CutOff1, exponent: Linfinity };
-Box::new(Named { name, data : ExperimentV2 {
+Box::new(Named {
-domain : [[0.0, 1.0]].into(),
+name,
-sensor_count : [N_SENSORS_1D],
+data: ExperimentV2 {
-regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.08)),
+domain: [[0.0, 1.0]].into(),
-noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.2))?,
+sensor_count: [N_SENSORS_1D],
-dataterm : DataTerm::L2Squared,
+regularisation: Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.08)),
-μ_hat : MU_TRUE_1D_BASIC.into(),
+noise_distr: SerializableNormal::new(0.0, cli.variance.unwrap_or(0.2))?,
-sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity },
+dataterm: DataTermType::L222,
-spread : Prod(spread_cutoff, base_spread),
+μ_hat: MU_TRUE_1D_BASIC.into(),
-kernel : Prod(AutoConvolution(spread_cutoff), base_spread),
+sensor: BallIndicator { r: SensorWidth1D, exponent: Linfinity },
-kernel_plot_width,
+spread: Prod(spread_cutoff, base_spread),
-noise_seed,
+kernel: Prod(AutoConvolution(spread_cutoff), base_spread),
-default_merge_radius,
+kernel_plot_width,
-algorithm_overrides: HashMap::from([
+noise_seed,
-sliding_fb_cut_gaussian,
+default_merge_radius,
-higher_cpos_merging(DefaultAlgorithm::RadonFB),
+algorithm_overrides: HashMap::from([
-higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB),
+sliding_fb_cut_gaussian,
-]),
+higher_cpos_merging(DefaultAlgorithm::RadonFB),
-}})
+higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB),
-},
+]),
+},
+})
+}
 Experiment1DFast => {
-let base_spread = HatConv { radius : Hat1 };
+let base_spread = HatConv { radius: Hat1 };
-Box::new(Named { name, data : ExperimentV2 {
+Box::new(Named {
-domain : [[0.0, 1.0]].into(),
+name,
-sensor_count : [N_SENSORS_1D],
+data: ExperimentV2 {
-regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.06)),
+domain: [[0.0, 1.0]].into(),
-noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.2))?,
+sensor_count: [N_SENSORS_1D],
-dataterm : DataTerm::L2Squared,
+regularisation: Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.06)),
-μ_hat : MU_TRUE_1D_BASIC.into(),
+noise_distr: SerializableNormal::new(0.0, cli.variance.unwrap_or(0.2))?,
-sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity },
+dataterm: DataTermType::L222,
-spread : base_spread,
+μ_hat: MU_TRUE_1D_BASIC.into(),
-kernel : base_spread,
+sensor: BallIndicator { r: SensorWidth1D, exponent: Linfinity },
-kernel_plot_width,
+spread: base_spread,
-noise_seed,
+kernel: base_spread,
-default_merge_radius,
+kernel_plot_width,
-algorithm_overrides: HashMap::from([
+noise_seed,
-higher_cpos_merging(DefaultAlgorithm::RadonFB),
+default_merge_radius,
-higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB),
+algorithm_overrides: HashMap::from([
-]),
+higher_cpos_merging(DefaultAlgorithm::RadonFB),
-}})
+higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB),
-},
+]),
+},
+})
+}
 Experiment2D => {
-let base_spread = Gaussian { variance : Variance1 };
+let base_spread = Gaussian { variance: Variance1 };
-let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity };
+let spread_cutoff = BallIndicator { r: CutOff1, exponent: Linfinity };
-Box::new(Named { name, data : ExperimentV2 {
+Box::new(Named {
-domain : [[0.0, 1.0]; 2].into(),
+name,
-sensor_count : [N_SENSORS_2D; 2],
+data: ExperimentV2 {
-regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.19)),
+domain: [[0.0, 1.0]; 2].into(),
-noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.25))?,
+sensor_count: [N_SENSORS_2D; 2],
-dataterm : DataTerm::L2Squared,
+regularisation: Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.19)),
-μ_hat : MU_TRUE_2D_BASIC.into(),
+noise_distr: SerializableNormal::new(0.0, cli.variance.unwrap_or(0.25))?,
-sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity },
+dataterm: DataTermType::L222,
-spread : Prod(spread_cutoff, base_spread),
+μ_hat: MU_TRUE_2D_BASIC.into(),
-kernel : Prod(AutoConvolution(spread_cutoff), base_spread),
+sensor: BallIndicator { r: SensorWidth2D, exponent: Linfinity },
-kernel_plot_width,
+spread: Prod(spread_cutoff, base_spread),
-noise_seed,
+kernel: Prod(AutoConvolution(spread_cutoff), base_spread),
-default_merge_radius,
+kernel_plot_width,
-algorithm_overrides: HashMap::from([
+noise_seed,
-sliding_fb_cut_gaussian,
+default_merge_radius,
-higher_cpos_merging(DefaultAlgorithm::RadonFB),
+algorithm_overrides: HashMap::from([
-higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB),
+sliding_fb_cut_gaussian,
-]),
+higher_cpos_merging(DefaultAlgorithm::RadonFB),
-}})
+higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB),
-},
+]),
+},
+})
+}
 Experiment2DFast => {
-let base_spread = HatConv { radius : Hat1 };
+let base_spread = HatConv { radius: Hat1 };
-Box::new(Named { name, data : ExperimentV2 {
+Box::new(Named {
-domain : [[0.0, 1.0]; 2].into(),
+name,
-sensor_count : [N_SENSORS_2D; 2],
+data: ExperimentV2 {
-regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.12)),
+domain: [[0.0, 1.0]; 2].into(),
-noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.15))?, //0.25
+sensor_count: [N_SENSORS_2D; 2],
-dataterm : DataTerm::L2Squared,
+regularisation: Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.12)),
-μ_hat : MU_TRUE_2D_BASIC.into(),
+noise_distr: SerializableNormal::new(0.0, cli.variance.unwrap_or(0.15))?, //0.25
-sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity },
+dataterm: DataTermType::L222,
-spread : base_spread,
+μ_hat: MU_TRUE_2D_BASIC.into(),
-kernel : base_spread,
+sensor: BallIndicator { r: SensorWidth2D, exponent: Linfinity },
-kernel_plot_width,
+spread: base_spread,
-noise_seed,
+kernel: base_spread,
-default_merge_radius,
+kernel_plot_width,
-algorithm_overrides: HashMap::from([
+noise_seed,
-higher_cpos_merging(DefaultAlgorithm::RadonFB),
+default_merge_radius,
-higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB),
+algorithm_overrides: HashMap::from([
-]),
+higher_cpos_merging(DefaultAlgorithm::RadonFB),
-}})
+higher_cpos_merging(DefaultAlgorithm::RadonSlidingFB),
-},
+]),
+},
+})
+}
 Experiment1D_L1 => {
-let base_spread = Gaussian { variance : Variance1 };
+let base_spread = Gaussian { variance: Variance1 };
-let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity };
+let spread_cutoff = BallIndicator { r: CutOff1, exponent: Linfinity };
-Box::new(Named { name, data : ExperimentV2 {
+Box::new(Named {
-domain : [[0.0, 1.0]].into(),
+name,
-sensor_count : [N_SENSORS_1D],
+data: ExperimentV2 {
-regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.1)),
+domain: [[0.0, 1.0]].into(),
-noise_distr : SaltAndPepper::new(
+sensor_count: [N_SENSORS_1D],
-cli.salt_and_pepper.as_ref().map_or(0.6, |v| v[0]),
+regularisation: Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.1)),
-cli.salt_and_pepper.as_ref().map_or(0.4, |v| v[1])
+noise_distr: SaltAndPepper::new(
-)?,
+cli.salt_and_pepper.as_ref().map_or(0.6, |v| v[0]),
-dataterm : DataTerm::L1,
+cli.salt_and_pepper.as_ref().map_or(0.4, |v| v[1]),
-μ_hat : MU_TRUE_1D_BASIC.into(),
+)?,
-sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity },
+dataterm: DataTermType::L1,
-spread : Prod(spread_cutoff, base_spread),
+μ_hat: MU_TRUE_1D_BASIC.into(),
-kernel : Prod(AutoConvolution(spread_cutoff), base_spread),
+sensor: BallIndicator { r: SensorWidth1D, exponent: Linfinity },
-kernel_plot_width,
+spread: Prod(spread_cutoff, base_spread),
-noise_seed,
+kernel: Prod(AutoConvolution(spread_cutoff), base_spread),
-default_merge_radius,
+kernel_plot_width,
-algorithm_overrides: HashMap::new(),
+noise_seed,
-}})
+default_merge_radius,
-},
+algorithm_overrides: HashMap::new(),
+},
+})
+}
 Experiment1D_L1_Fast => {
-let base_spread = HatConv { radius : Hat1 };
+let base_spread = HatConv { radius: Hat1 };
-Box::new(Named { name, data : ExperimentV2 {
+Box::new(Named {
-domain : [[0.0, 1.0]].into(),
+name,
-sensor_count : [N_SENSORS_1D],
+data: ExperimentV2 {
-regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.12)),
+domain: [[0.0, 1.0]].into(),
-noise_distr : SaltAndPepper::new(
+sensor_count: [N_SENSORS_1D],
-cli.salt_and_pepper.as_ref().map_or(0.6, |v| v[0]),
+regularisation: Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.12)),
-cli.salt_and_pepper.as_ref().map_or(0.4, |v| v[1])
+noise_distr: SaltAndPepper::new(
-)?,
+cli.salt_and_pepper.as_ref().map_or(0.6, |v| v[0]),
-dataterm : DataTerm::L1,
+cli.salt_and_pepper.as_ref().map_or(0.4, |v| v[1]),
-μ_hat : MU_TRUE_1D_BASIC.into(),
+)?,
-sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity },
+dataterm: DataTermType::L1,
-spread : base_spread,
+μ_hat: MU_TRUE_1D_BASIC.into(),
-kernel : base_spread,
+sensor: BallIndicator { r: SensorWidth1D, exponent: Linfinity },
-kernel_plot_width,
+spread: base_spread,
-noise_seed,
+kernel: base_spread,
-default_merge_radius,
+kernel_plot_width,
-algorithm_overrides: HashMap::new(),
+noise_seed,
-}})
+default_merge_radius,
-},
+algorithm_overrides: HashMap::new(),
+},
+})
+}
 Experiment2D_L1 => {
-let base_spread = Gaussian { variance : Variance1 };
+let base_spread = Gaussian { variance: Variance1 };
-let spread_cutoff = BallIndicator { r : CutOff1, exponent : Linfinity };
+let spread_cutoff = BallIndicator { r: CutOff1, exponent: Linfinity };
-Box::new(Named { name, data : ExperimentV2 {
+Box::new(Named {
-domain : [[0.0, 1.0]; 2].into(),
+name,
-sensor_count : [N_SENSORS_2D; 2],
+data: ExperimentV2 {
-regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.35)),
+domain: [[0.0, 1.0]; 2].into(),
-noise_distr : SaltAndPepper::new(
+sensor_count: [N_SENSORS_2D; 2],
-cli.salt_and_pepper.as_ref().map_or(0.8, |v| v[0]),
+regularisation: Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.35)),
-cli.salt_and_pepper.as_ref().map_or(0.2, |v| v[1])
+noise_distr: SaltAndPepper::new(
-)?,
+cli.salt_and_pepper.as_ref().map_or(0.8, |v| v[0]),
-dataterm : DataTerm::L1,
+cli.salt_and_pepper.as_ref().map_or(0.2, |v| v[1]),
-μ_hat : MU_TRUE_2D_BASIC.into(),
+)?,
-sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity },
+dataterm: DataTermType::L1,
-spread : Prod(spread_cutoff, base_spread),
+μ_hat: MU_TRUE_2D_BASIC.into(),
-kernel : Prod(AutoConvolution(spread_cutoff), base_spread),
+sensor: BallIndicator { r: SensorWidth2D, exponent: Linfinity },
-kernel_plot_width,
+spread: Prod(spread_cutoff, base_spread),
-noise_seed,
+kernel: Prod(AutoConvolution(spread_cutoff), base_spread),
-default_merge_radius,
+kernel_plot_width,
-algorithm_overrides: HashMap::from([
+noise_seed,
-]),
+default_merge_radius,
-}})
+algorithm_overrides: HashMap::from([]),
 },
+})
+}
 Experiment2D_L1_Fast => {
-let base_spread = HatConv { radius : Hat1 };
+let base_spread = HatConv { radius: Hat1 };
-Box::new(Named { name, data : ExperimentV2 {
+Box::new(Named {
-domain : [[0.0, 1.0]; 2].into(),
+name,
-sensor_count : [N_SENSORS_2D; 2],
+data: ExperimentV2 {
-regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.40)),
+domain: [[0.0, 1.0]; 2].into(),
-noise_distr : SaltAndPepper::new(
+sensor_count: [N_SENSORS_2D; 2],
-cli.salt_and_pepper.as_ref().map_or(0.8, |v| v[0]),
+regularisation: Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.40)),
-cli.salt_and_pepper.as_ref().map_or(0.2, |v| v[1])
+noise_distr: SaltAndPepper::new(
-)?,
+cli.salt_and_pepper.as_ref().map_or(0.8, |v| v[0]),
-dataterm : DataTerm::L1,
+cli.salt_and_pepper.as_ref().map_or(0.2, |v| v[1]),
-μ_hat : MU_TRUE_2D_BASIC.into(),
+)?,
-sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity },
+dataterm: DataTermType::L1,
-spread : base_spread,
+μ_hat: MU_TRUE_2D_BASIC.into(),
-kernel : base_spread,
+sensor: BallIndicator { r: SensorWidth2D, exponent: Linfinity },
-kernel_plot_width,
+spread: base_spread,
-noise_seed,
+kernel: base_spread,
-default_merge_radius,
+kernel_plot_width,
-algorithm_overrides: HashMap::from([
+noise_seed,
-]),
+default_merge_radius,
-}})
+algorithm_overrides: HashMap::from([]),
 },
+})
+}
 Experiment1D_TV_Fast => {
-let base_spread = HatConv { radius : HatBias };
+let base_spread = HatConv { radius: HatBias };
-Box::new(Named { name, data : ExperimentBiased {
+Box::new(Named {
-λ : 0.02,
+name,
-bias : MappingSum::new([
+data: ExperimentBiased {
-Weighted::new(1.0, BallCharacteristic{ center : 0.3.into(), radius : 0.2 }),
+λ: 0.02,
-Weighted::new(0.5, BallCharacteristic{ center : 0.6.into(), radius : 0.3 }),
+bias: MappingSum::new([
-]),
+Weighted::new(1.0, BallCharacteristic {
-base : ExperimentV2 {
+center: 0.3.into(),
-domain : [[0.0, 1.0]].into(),
+radius: 0.2,
-sensor_count : [N_SENSORS_1D],
+}),
-regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.2)),
+Weighted::new(0.5, BallCharacteristic {
-noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.1))?,
+center: 0.6.into(),
-dataterm : DataTerm::L2Squared,
+radius: 0.3,
-μ_hat : MU_TRUE_1D_BASIC.into(),
+}),
-sensor : BallIndicator { r : SensorWidth1D, exponent : Linfinity },
-spread : base_spread,
-kernel : base_spread,
-kernel_plot_width,
-noise_seed,
-default_merge_radius,
-algorithm_overrides: HashMap::from([
-higher_cpos_merging_steptune(DefaultAlgorithm::RadonForwardPDPS),
-higher_cpos_merging_steptune(DefaultAlgorithm::RadonSlidingPDPS),
 ]),
-},
+base: ExperimentV2 {
-}})
+domain: [[0.0, 1.0]].into(),
-},
+sensor_count: [N_SENSORS_1D],
+regularisation: Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.2)),
+noise_distr: SerializableNormal::new(0.0, cli.variance.unwrap_or(0.1))?,
+dataterm: DataTermType::L222,
+μ_hat: MU_TRUE_1D_BASIC.into(),
+sensor: BallIndicator { r: SensorWidth1D, exponent: Linfinity },
+spread: base_spread,
+kernel: base_spread,
+kernel_plot_width,
+noise_seed,
+default_merge_radius,
+algorithm_overrides: HashMap::from([
+higher_cpos_merging_steptune(DefaultAlgorithm::RadonForwardPDPS),
+higher_cpos_merging_steptune(DefaultAlgorithm::RadonSlidingPDPS),
+]),
+},
+},
+})
+}
 Experiment2D_TV_Fast => {
-let base_spread = HatConv { radius : Hat1 };
+let base_spread = HatConv { radius: Hat1 };
-Box::new(Named { name, data : ExperimentBiased {
+Box::new(Named {
-λ : 0.005,
+name,
-bias : MappingSum::new([
+data: ExperimentBiased {
-Weighted::new(1.0, BallCharacteristic{ center : [0.3, 0.3].into(), radius : 0.2 }),
+λ: 0.005,
-Weighted::new(0.5, BallCharacteristic{ center : [0.6, 0.6].into(), radius : 0.3 }),
+bias: MappingSum::new([
-]),
+Weighted::new(1.0, BallCharacteristic {
-base : ExperimentV2 {
+center: [0.3, 0.3].into(),
-domain : [[0.0, 1.0]; 2].into(),
+radius: 0.2,
-sensor_count : [N_SENSORS_2D; 2],
+}),
-regularisation : Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.06)),
+Weighted::new(0.5, BallCharacteristic {
-noise_distr : SerializableNormal::new(0.0, cli.variance.unwrap_or(0.15))?, //0.25
+center: [0.6, 0.6].into(),
-dataterm : DataTerm::L2Squared,
+radius: 0.3,
-μ_hat : MU_TRUE_2D_BASIC.into(),
+}),
-sensor : BallIndicator { r : SensorWidth2D, exponent : Linfinity },
-spread : base_spread,
-kernel : base_spread,
-kernel_plot_width,
-noise_seed,
-default_merge_radius,
-algorithm_overrides: HashMap::from([
-much_higher_cpos_merging_steptune(DefaultAlgorithm::RadonForwardPDPS),
-much_higher_cpos_merging_steptune(DefaultAlgorithm::RadonSlidingPDPS),
 ]),
-},
+base: ExperimentV2 {
-}})
+domain: [[0.0, 1.0]; 2].into(),
-},
+sensor_count: [N_SENSORS_2D; 2],
+regularisation: Regularisation::NonnegRadon(cli.alpha.unwrap_or(0.06)),
+noise_distr: SerializableNormal::new(
+0.0,
+cli.variance.unwrap_or(0.15),
+)?, //0.25
+dataterm: DataTermType::L222,
+μ_hat: MU_TRUE_2D_BASIC.into(),
+sensor: BallIndicator { r: SensorWidth2D, exponent: Linfinity },
+spread: base_spread,
+kernel: base_spread,
+kernel_plot_width,
+noise_seed,
+default_merge_radius,
+algorithm_overrides: HashMap::from([
+much_higher_cpos_merging_steptune(
+DefaultAlgorithm::RadonForwardPDPS,
+),
+much_higher_cpos_merging_steptune(
+DefaultAlgorithm::RadonSlidingPDPS,
+),
+]),
+},
+},
+})
+}
 })
 }
 }

Mercurial > repos > pointsource_algs / file comparison

comparison: src/experiments.rs

src/experiments.rs