pointsource_algs: comparison src/lib.rs

-:e2953ffd4e0b
+:e9a460a0e638
 use alg_tools::error::DynResult;
 use alg_tools::parallelism::{set_max_threads, set_num_threads};
 use clap::Parser;
 use serde::{Deserialize, Serialize};
-use serde_json;
 use serde_with::skip_serializing_none;
 use std::num::NonZeroUsize;
 //#[cfg(feature = "pyo3")]
 //use pyo3::pyclass;
 pub mod measures {
 pub use measures::*;
 }
-use run::{AlgorithmConfig, DefaultAlgorithm, Named, PlotLevel, RunnableExperiment};
+use run::{DefaultAlgorithm, PlotLevel, RunnableExperiment};
 use subproblem::InnerMethod;
 use types::{ClapFloat, Float};
-use DefaultAlgorithm::*;
 /// Trait for customising the experiments available from the command line
 pub trait ExperimentSetup:
 clap::Args + Send + Sync + 'static + Serialize + for<'a> Deserialize<'a>
 {
 /// Default algorithm configration(s) to use on the experiments.
 ///
 /// Not all algorithms are available for all the experiments.
 /// In particular, only PDPS is available for the experiments with L¹ data term.
-#[arg(value_enum, value_name = "ALGORITHM", long, short = 'a',
+#[arg(value_enum, value_name = "ALGORITHM", long, short = 'a')]
-default_values_t = [FB, PDPS, SlidingFB, FW, RadonFB])]
 algorithm: Vec<DefaultAlgorithm>,
 /// Saved algorithm configration(s) to use on the experiments
 #[arg(value_name = "JSON_FILE", long)]
 saved_algorithm: Vec<String>,
 #[arg(long, value_names = &["COUNT", "EACH"])]
 /// Override bootstrap insertion iterations for --algorithm.
 ///
 /// The first parameter is the number of bootstrap insertion iterations, and the second
 /// the maximum number of iterations on each of them.
-bootstrap_insertions: Option<Vec<usize>>,
+pub bootstrap_insertions: Option<Vec<usize>>,
 #[arg(long, requires = "algorithm")]
 /// Primal step length parameter override for --algorithm.
 ///
 /// Only use if running just a single algorithm, as different algorithms have different
 /// regularisation parameters. Does not affect the algorithms fw and fwrelax.
-tau0: Option<F>,
+pub tau0: Option<F>,
 #[arg(long, requires = "algorithm")]
 /// Second primal step length parameter override for SlidingPDPS.
 ///
 /// Only use if running just a single algorithm, as different algorithms have different
 /// regularisation parameters.
-sigmap0: Option<F>,
+pub sigmap0: Option<F>,
 #[arg(long, requires = "algorithm")]
 /// Dual step length parameter override for --algorithm.
 ///
 /// Only use if running just a single algorithm, as different algorithms have different
 /// regularisation parameters. Only affects PDPS.
-sigma0: Option<F>,
+pub sigma0: Option<F>,
 #[arg(long)]
 /// Normalised transport step length for sliding methods.
-theta0: Option<F>,
+pub theta0: Option<F>,
 #[arg(long)]
-/// A posteriori transport tolerance multiplier (C_pos)
+/// Unnormalised transport step length for sliding methods, multiplied by tau.
-transport_tolerance_pos: Option<F>,
+pub tautheta: Option<F>,
+#[arg(long)]
+/// A posteriori transport tolerance multiplier
+pub transport_tolerance: Option<F>,
+#[arg(long)]
+/// Multiplier for rough estimate of ℓ_{∇v}. Should be ≥ 1.
+/// If explicit τθ is given, ℓ_{∇v} is one divided by this number times τθ.
+/// Otherwise, if  τθ relative to an estimate of ℓ_{∇v}, this number multiplies that estimate.
+pub gradv_lipest_mult: Option<F>,
 #[arg(long)]
 /// Transport adaptation factor. Must be in (0, 1).
-transport_adaptation: Option<F>,
+pub transport_adaptation: Option<F>,
+#[arg(long)]
+/// Whether partially transported spikes are allowed.
+pub allow_partial_transport: Option<bool>,
+#[arg(long)]
+/// Use an alternative remainder control rule.
+pub alt_remainder_control: Option<bool>,
 #[arg(long)]
 /// Minimal step length parameter for sliding methods.
-tau0_min: Option<F>,
+pub tau0_min: Option<F>,
 #[arg(value_enum, long)]
 /// PDPS acceleration, when available.
-acceleration: Option<pdps::Acceleration>,
+pub acceleration: Option<pdps::Acceleration>,
 // #[arg(long)]
 // /// Perform postprocess weight optimisation for saved iterations
 // ///
 // /// Only affects FB, FISTA, and PDPS.
 // postprocessing : Option<bool>,
 #[arg(value_name = "n", long)]
 /// Merging frequency, if merging enabled (every n iterations)
 ///
 /// Only affects FB, FISTA, and PDPS.
-merge_every: Option<usize>,
+pub merge_every: Option<usize>,
 #[arg(long)]
 /// Enable merging (default: determined by algorithm)
-merge: Option<bool>,
+pub merge: Option<bool>,
 #[arg(long)]
 /// Merging radius (default: determined by experiment)
-merge_radius: Option<F>,
+pub merge_radius: Option<F>,
 #[arg(long)]
 /// Interpolate when merging (default : determined by algorithm)
-merge_interp: Option<bool>,
+pub merge_interp: Option<bool>,
 #[arg(long)]
 /// Enable final merging (default: determined by algorithm)
-final_merging: Option<bool>,
+pub final_merging: Option<bool>,
 #[arg(long)]
 /// Enable fitness-based merging for relevant FB-type methods.
 /// This has worse convergence guarantees that merging based on optimality conditions.
-fitness_merging: Option<bool>,
+pub fitness_merging: Option<bool>,
 #[arg(long, value_names = &["ε", "θ", "p"])]
 /// Set the tolerance to ε_k = ε/(1+θk)^p
-tolerance: Option<Vec<F>>,
+pub tolerance: Option<Vec<F>>,
 #[arg(long)]
 /// Method for solving inner optimisation problems
-inner_method: Option<InnerMethod>,
+pub inner_method: Option<InnerMethod>,
 #[arg(long)]
 /// Step length parameter for inner problem
-inner_τ0: Option<F>,
+pub inner_τ0: Option<F>,
 #[arg(long, value_names = &["τ0", "σ0"])]
 /// Dual step length parameter for inner problem
-inner_pdps_τσ0: Option<Vec<F>>,
+pub inner_pdps_τσ0: Option<Vec<F>>,
 #[arg(long, value_names = &["τ", "growth"])]
 /// Inner proximal point method step length and its growth
-inner_pp_τ: Option<Vec<F>>,
+pub inner_pp_τ: Option<Vec<F>>,
 #[arg(long)]
 /// Inner tolerance multiplier
-inner_tol: Option<F>,
+pub inner_tol: Option<F>,
 }
 /// A generic entry point for binaries based on this library
 pub fn common_main<E: ExperimentSetup>() -> DynResult<()> {
-let full_cli = FusedCommandLineArgs::<E>::parse();
+let cli = FusedCommandLineArgs::<E>::parse();
-let cli = &full_cli.general;
 #[cfg(debug_assertions)]
 {
 use colored::Colorize;
 println!(
 )
 .red()
 );
 }
-if let Some(n_threads) = cli.num_threads {
+if let Some(n_threads) = cli.general.num_threads {
 let n = NonZeroUsize::new(n_threads).expect("Invalid thread count");
 set_num_threads(n);
 } else {
-let m = NonZeroUsize::new(cli.max_threads).expect("Invalid maximum thread count");
+let m = NonZeroUsize::new(cli.general.max_threads).expect("Invalid maximum thread count");
 set_max_threads(m);
 }
-for experiment in full_cli.experiment_setup.runnables()? {
+for experiment in cli.experiment_setup.runnables()? {
-let mut algs: Vec<Named<AlgorithmConfig<E::FloatType>>> = cli
+experiment.runall(&cli.general, &cli.algorithm_overrides)?;
-.algorithm
-.iter()
-.map(|alg| {
-let cfg = alg
-.default_config()
-.cli_override(&experiment.algorithm_overrides(*alg))
-.cli_override(&full_cli.algorithm_overrides);
-alg.to_named(cfg)
-})
-.collect();
-for filename in cli.saved_algorithm.iter() {
-let f = std::fs::File::open(filename)?;
-let alg = serde_json::from_reader(f)?;
-algs.push(alg);
-}
-experiment.runall(&cli, (!algs.is_empty()).then_some(algs))?;
 }
 Ok(())
 }

Mercurial > repos > pointsource_algs / file comparison

comparison: src/lib.rs

src/lib.rs