diff -r 39c5e6c7759d -r 0693cc9ba9f0 src/prox_penalty.rs
--- a/src/prox_penalty.rs	Mon Feb 17 13:45:11 2025 -0500
+++ b/src/prox_penalty.rs	Mon Feb 17 13:51:50 2025 -0500
@@ -2,119 +2,114 @@
 Proximal penalty abstraction
 */
 
+use alg_tools::types::*;
 use numeric_literals::replace_float_literals;
-use alg_tools::types::*;
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
+use crate::measures::merging::SpikeMergingMethod;
+use crate::measures::RNDM;
+use crate::regularisation::RegTerm;
+use crate::subproblem::InnerSettings;
+use crate::tolerance::Tolerance;
+use crate::types::{IterInfo, RefinementSettings};
+use alg_tools::iterate::{AlgIterator, AlgIteratorIteration};
 use alg_tools::mapping::RealMapping;
 use alg_tools::nalgebra_support::ToNalgebraRealField;
-use alg_tools::iterate::{
-    AlgIteratorIteration,
-    AlgIterator,
-};
-use crate::measures::RNDM;
-use crate::types::{
-    RefinementSettings,
-    IterInfo,
-};
-use crate::subproblem::InnerSettings;
-use crate::tolerance::Tolerance;
-use crate::measures::merging::SpikeMergingMethod;
-use crate::regularisation::RegTerm;
 
+pub mod radon_squared;
 pub mod wave;
-pub mod radon_squared;
 pub use radon_squared::RadonSquared;
 
 /// Settings for the solution of the stepwise optimality condition.
 #[derive(Clone, Copy, Eq, PartialEq, Serialize, Deserialize, Debug)]
 #[serde(default)]
-pub struct FBGenericConfig<F : Float> {
+pub struct FBGenericConfig<F: Float> {
     /// Tolerance for point insertion.
-    pub tolerance : Tolerance<F>,
+    pub tolerance: Tolerance<F>,
 
     /// Stop looking for predual maximum (where to isert a new point) below
     /// `tolerance` multiplied by this factor.
     ///
-    /// Not used by [`super::radon_fb`].
-    pub insertion_cutoff_factor : F,
+    /// Not used by [`crate::prox_penalty::radon_squared`].
+    pub insertion_cutoff_factor: F,
 
     /// Settings for branch and bound refinement when looking for predual maxima
-    pub refinement : RefinementSettings<F>,
+    pub refinement: RefinementSettings<F>,
 
     /// Maximum insertions within each outer iteration
     ///
-    /// Not used by [`super::radon_fb`].
-    pub max_insertions : usize,
+    /// Not used by [`crate::prox_penalty::radon_squared`].
+    pub max_insertions: usize,
 
     /// Pair `(n, m)` for maximum insertions `m` on first `n` iterations.
     ///
-    /// Not used by [`super::radon_fb`].
-    pub bootstrap_insertions : Option<(usize, usize)>,
+    /// Not used by [`crate::prox_penalty::radon_squared`].
+    pub bootstrap_insertions: Option<(usize, usize)>,
 
     /// Inner method settings
-    pub inner : InnerSettings<F>,
+    pub inner: InnerSettings<F>,
 
     /// Spike merging method
-    pub merging : SpikeMergingMethod<F>,
+    pub merging: SpikeMergingMethod<F>,
 
     /// Tolerance multiplier for merges
-    pub merge_tolerance_mult : F,
+    pub merge_tolerance_mult: F,
 
     /// Merge spikes after last step (even if merging not generally enabled)
-    pub final_merging : bool,
+    pub final_merging: bool,
 
     /// Use fitness as merging criterion. Implies worse convergence guarantees.
-    pub fitness_merging : bool,
+    pub fitness_merging: bool,
 
     /// Iterations between merging heuristic tries
-    pub merge_every : usize,
-
+    pub merge_every: usize,
     // /// Save $μ$ for postprocessing optimisation
     // pub postprocessing : bool
 }
 
 #[replace_float_literals(F::cast_from(literal))]
-impl<F : Float> Default for FBGenericConfig<F> {
+impl<F: Float> Default for FBGenericConfig<F> {
     fn default() -> Self {
         FBGenericConfig {
-            tolerance : Default::default(),
-            insertion_cutoff_factor : 1.0,
-            refinement : Default::default(),
-            max_insertions : 100,
+            tolerance: Default::default(),
+            insertion_cutoff_factor: 1.0,
+            refinement: Default::default(),
+            max_insertions: 100,
             //bootstrap_insertions : None,
-            bootstrap_insertions : Some((10, 1)),
-            inner : Default::default(),
-            merging : Default::default(),
-            final_merging : true,
-            fitness_merging : false,
-            merge_every : 10,
-            merge_tolerance_mult : 2.0,
+            bootstrap_insertions: Some((10, 1)),
+            inner: Default::default(),
+            merging: Default::default(),
+            final_merging: true,
+            fitness_merging: false,
+            merge_every: 10,
+            merge_tolerance_mult: 2.0,
             // postprocessing : false,
         }
     }
 }
 
-impl<F : Float> FBGenericConfig<F> {
+impl<F: Float> FBGenericConfig<F> {
     /// Check if merging should be attempted this iteration
-    pub fn merge_now<I : AlgIterator>(&self, state : &AlgIteratorIteration<I>) -> bool {
+    pub fn merge_now<I: AlgIterator>(&self, state: &AlgIteratorIteration<I>) -> bool {
         self.merging.enabled && state.iteration() % self.merge_every == 0
     }
 
     /// Returns the final merging method
     pub fn final_merging_method(&self) -> SpikeMergingMethod<F> {
-        SpikeMergingMethod{ enabled : self.final_merging, ..self.merging}
+        SpikeMergingMethod {
+            enabled: self.final_merging,
+            ..self.merging
+        }
     }
 }
 
-
 /// Trait for proximal penalties
-pub trait ProxPenalty<F, PreadjointCodomain, Reg, const N : usize>
+pub trait ProxPenalty<F, PreadjointCodomain, Reg, const N: usize>
 where
-    F : Float + ToNalgebraRealField,
-    Reg : RegTerm<F, N>,
+    F: Float + ToNalgebraRealField,
+    Reg: RegTerm<F, N>,
 {
-    type ReturnMapping : RealMapping<F, N>;
+    type ReturnMapping: RealMapping<F, N>;
 
     /// Insert new spikes into `μ` to approximately satisfy optimality conditions
     /// with the forward step term fixed to `τv`.
@@ -125,24 +120,23 @@
     /// `μ_base + ν_delta` is the base point, where `μ` and `μ_base` are assumed to have the same
     /// spike locations, while `ν_delta` may have different locations.
     ///
-    /// `τv` is mutable to allow [`alg_tools::bisection_tree::btfn::BTFN`] refinement.
+    /// `τv` is mutable to allow [`alg_tools::bisection_tree::BTFN`] refinement.
     /// Actual values of `τv` are not supposed to be mutated.
     fn insert_and_reweigh<I>(
         &self,
-        μ : &mut RNDM<F, N>,
-        τv : &mut PreadjointCodomain,
-        μ_base : &RNDM<F, N>,
+        μ: &mut RNDM<F, N>,
+        τv: &mut PreadjointCodomain,
+        μ_base: &RNDM<F, N>,
         ν_delta: Option<&RNDM<F, N>>,
-        τ : F,
-        ε : F,
-        config : &FBGenericConfig<F>,
-        reg : &Reg,
-        state : &AlgIteratorIteration<I>,
-        stats : &mut IterInfo<F, N>,
+        τ: F,
+        ε: F,
+        config: &FBGenericConfig<F>,
+        reg: &Reg,
+        state: &AlgIteratorIteration<I>,
+        stats: &mut IterInfo<F, N>,
     ) -> (Option<Self::ReturnMapping>, bool)
     where
-        I : AlgIterator;
-
+        I: AlgIterator;
 
     /// Merge spikes, if possible.
     ///
@@ -151,39 +145,48 @@
     /// is set.
     fn merge_spikes(
         &self,
-        μ : &mut RNDM<F, N>,
-        τv : &mut PreadjointCodomain,
-        μ_base : &RNDM<F, N>,
+        μ: &mut RNDM<F, N>,
+        τv: &mut PreadjointCodomain,
+        μ_base: &RNDM<F, N>,
         ν_delta: Option<&RNDM<F, N>>,
-        τ : F,
-        ε : F,
-        config : &FBGenericConfig<F>,
-        reg : &Reg,
-        fitness : Option<impl Fn(&RNDM<F, N>) -> F>,
+        τ: F,
+        ε: F,
+        config: &FBGenericConfig<F>,
+        reg: &Reg,
+        fitness: Option<impl Fn(&RNDM<F, N>) -> F>,
     ) -> usize;
 
     /// Merge spikes, if possible.
     ///
-    /// Unlike [`merge_spikes`], this variant only supports optimality condition based merging
+    /// Unlike [`Self::merge_spikes`], this variant only supports optimality condition based merging
     #[inline]
     fn merge_spikes_no_fitness(
         &self,
-        μ : &mut RNDM<F, N>,
-        τv : &mut PreadjointCodomain,
-        μ_base : &RNDM<F, N>,
+        μ: &mut RNDM<F, N>,
+        τv: &mut PreadjointCodomain,
+        μ_base: &RNDM<F, N>,
         ν_delta: Option<&RNDM<F, N>>,
-        τ : F,
-        ε : F,
-        config : &FBGenericConfig<F>,
-        reg : &Reg,
+        τ: F,
+        ε: F,
+        config: &FBGenericConfig<F>,
+        reg: &Reg,
     ) -> usize {
         /// This is a hack to create a `None` of same type as a `Some`
         // for the `impl Fn` parameter of `merge_spikes`.
         #[inline]
-        fn into_none<T>(_ : Option<T>) -> Option<T>{
+        fn into_none<T>(_: Option<T>) -> Option<T> {
             None
         }
-        self.merge_spikes(μ, τv, μ_base, ν_delta, τ, ε, config, reg,
-                          into_none(Some(|_ : &RNDM<F, N>| F::ZERO)))
+        self.merge_spikes(
+            μ,
+            τv,
+            μ_base,
+            ν_delta,
+            τ,
+            ε,
+            config,
+            reg,
+            into_none(Some(|_: &RNDM<F, N>| F::ZERO)),
+        )
     }
 }