# shrinkage::ChainFusedLasso Shrinkage for Rust · 0.3.0 [Source]() ```rust pub struct ChainFusedLasso ``` Complete penalty `l1 * sum_j |beta[j]| + fusion * sum_j w[j] * |beta[j+1]-beta[j]|`. Edges follow feature order and contribute once. Both strengths and every weight must be finite and nonnegative, checked on use. Unit weights are implicit unless [`Self::with_weights`]() supplies exactly one weight per edge. Zero weights cut the chain. Empty and single-feature chains have no edges. Intercepts are excluded, and coefficients refer to the optimization scale. The exact complete prox uses weighted taut strings followed by uniform L1 soft-thresholding. Value and prox take `O(p)` time; the prox reuses `O(p)` CPU storage. [`crate::ProximalGradient`]() supports typed and runtime problems, and [`crate::HybridCoordinateDescent`](<6e142c2de8c70807e35ff7553fffda094241be993dc7a332ee193688dc1f04bf>) adds exact Gaussian segment-coordinate sweeps. ```rust use shrinkage::{ChainFusedLasso, Penalty, ProximalPenalty}; let penalty = ChainFusedLasso::new(0.1, 0.2).with_weights(vec![2.0, 0.0]); assert!((penalty.value(&[-2.0, 2.0, 1.0])? - 2.1).abs() < 1e-14); let mut output = [0.0; 3]; penalty.prox(&[-2.0, 2.0, 1.0], 1.0, &mut output)?; assert_eq!(output, [-1.5, 1.5, 0.9]); ``` ## Inherent implementation [Source]() ```rust impl ChainFusedLasso ``` ### `fusion` ```rust pub fn fusion(&self) -> f64 ``` [Source]() Configured multiplier of the edge weights. ### `l1` ```rust pub fn l1(&self) -> f64 ``` [Source]() Configured L1 strength. ### `new` ```rust pub fn new(l1: f64, fusion: f64) -> Self ``` [Source]() Set independent L1 and fusion strengths, with implicit unit weights. ### `weights` ```rust pub fn weights(&self) -> Option<&[f64]> ``` [Source]() Explicit edge weights, or `None` for implicit unit weights. ### `with_weights` ```rust pub fn with_weights(self, weights: Vec) -> Self ``` [Source]() Supply one finite, nonnegative weight per adjacent edge, checked on use. ## Implementation of Clone [Source]() ```rust impl Clone for ChainFusedLasso ``` ### `clone` ```rust fn clone(&self) -> Self ``` [Source]() ## Implementation of Debug [Source]() ```rust impl Debug for ChainFusedLasso ``` ### `fmt` ```rust fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result ``` [Source]() ## [Implementation of GapSafePenalty](<70ffed513f4897153138a3d474faab53b31c338c10fd2b0945fd39cc01a58a42>) [Source]() ```rust impl GapSafePenalty for shrinkage::ChainFusedLasso ``` ### `dual_feasible` ```rust fn dual_feasible( &self, correlations: &[f64], errors: &[f64] ) -> Result ``` [Source]() ### `has_sparsity` ```rust fn has_sparsity(&self) -> bool ``` [Source]() ### `prox_zeroed` ```rust fn prox_zeroed( &self, input: &[f64], zeroed: &[bool], step: f64, output: &mut [f64] ) -> Result<(), FitError> ``` [Source]() ### `screen_zeros` ```rust fn screen_zeros( &self, correlations: &[f64], errors: &[f64], zeroed: &mut [bool] ) -> Result<(), FitError> ``` [Source]() ## Implementation of Partition [Source]() ```rust impl Partition for State ``` ### `labels` ```rust fn labels(&self) -> &[usize] ``` [Source]() ### `new` ```rust fn new(n: usize, p: usize) -> Self ``` [Source]() ### `rebuild` ```rust fn rebuild + lazymatrix::MatrixErrorType>( &mut self, matrix: &LazyMatrix, coefficients: &[f64], residual: &[f64], penalty: &ChainFusedLasso, iteration: usize ) -> Result<(), FitError<::Error>> ``` [Source]() ### `set_screened` ```rust fn set_screened(&mut self, zeroed: &[bool]) ``` [Source]() ### `set_weights` ```rust fn set_weights(&mut self, weights: &[f64]) ``` [Source]() ### `sweep_observed` ```rust fn sweep_observed( &mut self, coefficients: &mut [f64], intercept: &mut f64, fit_intercept: bool, penalty: &ChainFusedLasso, iteration: usize, observer: &mut T ) -> Result<(), FitError> ``` [Source]() ### `sweep_visits` ```rust fn sweep_visits(&self) -> (usize, usize) ``` [Source]() ### `values` ```rust fn values(&self) -> Vec ``` [Source]() ## [Implementation of PathPenalty](<5696a47a26612eb54b73987df7c9af737a60d396dd77d3c0b67969a3a5f37105>) [Source]() ```rust impl PathPenalty for shrinkage::ChainFusedLasso ``` ### `AtStrength` ```rust type AtStrength = ChainFusedLasso; ``` [Source]() ### `at_strength` ```rust fn at_strength(&self, lambda: f64) -> Result ``` [Source]() ### `maximum_penalty` ```rust fn maximum_penalty(&self, gradient: &[f64]) -> Result ``` [Source]() ## [Implementation of Penalty]() [Source]() ```rust impl Penalty for ChainFusedLasso ``` ### `Error` ```rust type Error = FitError; ``` [Source]() ### `validate_input` ```rust fn validate_input(&self, coefficients: &[f64]) -> Result<(), FitError> ``` [Source]() ### `value` ```rust fn value(&self, coefficients: &[f64]) -> Result ``` [Source]() ## [Implementation of ProximalPenalty](<45434a0394c5d718086e7e777f7db8271e2fb2b568e2519720168e5ea2877ed0>) [Source]() ```rust impl ProximalPenalty for ChainFusedLasso ``` ### `gap_safe` ```rust fn gap_safe(&self) -> Option<&dyn shrinkage::GapSafePenalty> ``` [Source]() ### `prox` ```rust fn prox( &self, input: &[f64], step: f64, output: &mut [f64] ) -> Result<(), FitError> ``` [Source]() ## Implementation of ReducedCoordinatePenalty [Source]() ```rust impl ReducedCoordinatePenalty for shrinkage::ChainFusedLasso ``` ### `State` ```rust type State = State; ``` [Source]() ## Implementation of Freeze ```rust impl !Freeze for ChainFusedLasso ``` ## Implementation of RefUnwindSafe ```rust impl !RefUnwindSafe for ChainFusedLasso ``` ## Implementation of Send ```rust impl Send for ChainFusedLasso ``` ## Implementation of Sync ```rust impl !Sync for ChainFusedLasso ``` ## Implementation of Unpin ```rust impl Unpin for ChainFusedLasso ``` ## Implementation of UnsafeUnpin ```rust impl UnsafeUnpin for ChainFusedLasso ``` ## Implementation of UnwindSafe ```rust impl UnwindSafe for ChainFusedLasso ``` ## Implementation of Any ```rust impl Any for T where T: 'static + ?Sized ``` ## Implementation of Borrow ```rust impl Borrow for T where T: ?Sized ``` ## Implementation of BorrowMut ```rust impl BorrowMut for T where T: ?Sized ``` ## Implementation of ByRef ```rust impl ByRef for T ``` ## Implementation of CastableFrom ```rust impl CastableFrom for DT where ST: ?Sized, DT: ?Sized ``` ## Implementation of CastableFrom ```rust impl CastableFrom for DT where ST: ?Sized, DT: ?Sized ``` ## Implementation of CloneToUninit ```rust impl CloneToUninit for T where T: Clone ``` ## Implementation of From ```rust impl From for T ``` ## Implementation of Imply ```rust impl Imply for U where T: ?Sized, U: ?Sized ``` ## Implementation of Into ```rust impl Into for T where U: From ``` ## Implementation of IntoEither ```rust impl IntoEither for T ``` ## Implementation of Pointable ```rust impl Pointable for T ``` ## Implementation of Read ```rust impl Read for T where T: ?Sized ``` ## Implementation of Same ```rust impl Same for T ``` ## Implementation of SupersetOf ```rust impl SupersetOf for SP where SS: SubsetOf ``` ## Implementation of ToOwned ```rust impl ToOwned for T where T: Clone ``` ## Implementation of TryFrom ```rust impl TryFrom for T where U: Into ``` ## Implementation of TryInto ```rust impl TryInto for T where U: TryFrom ```