# shrinkage::Slope Shrinkage for Rust · 0.3.0 [Source]() ```rust pub struct Slope ``` SLOPE penalty `sum_j weights[j] * |beta|_(j)` on optimization coefficients. `|beta|_(j)` denotes the jth largest coefficient magnitude. Supply one finite, nonnegative, nonincreasing weight per coefficient, including the penalty strength. Equal weights give L1; all zero weights give no penalty. An empty weight vector defines the penalty on an empty coefficient vector. Intercepts are excluded by the fitting APIs. The exact proximal map sorts magnitudes, projects the thresholded values onto nonincreasing, nonnegative sequences by pooling adjacent violations, and restores the original signs and order. Sorting costs `O(p log p)` and pooling costs `O(p)`. Owned CPU scratch storage is reused across calls. Typed Gaussian problems also support [`crate::HybridCoordinateDescent`](<6e142c2de8c70807e35ff7553fffda094241be993dc7a332ee193688dc1f04bf>), combining full PG transitions with exact signed magnitude-cluster sweeps. ```rust use shrinkage::{Penalty, ProximalPenalty, Slope}; let penalty = Slope::new(vec![3.0, 1.0]); assert_eq!(penalty.value(&[-3.0, 3.0])?, 12.0); let mut output = [0.0; 2]; penalty.prox(&[-3.0, 3.0], 1.0, &mut output)?; assert_eq!(output, [-1.0, 1.0]); ``` ## Inherent implementation [Source]() ```rust impl Slope ``` ### `new` ```rust pub fn new(weights: Vec) -> Self ``` [Source]() Set complete rank weights, checked during evaluation and fitting. ### `weights` ```rust pub fn weights(&self) -> &[f64] ``` [Source]() Configured rank weights, including the penalty strength. ## Implementation of Clone [Source]() ```rust impl Clone for Slope ``` ### `clone` ```rust fn clone(&self) -> Self ``` [Source]() ## Implementation of Debug [Source]() ```rust impl Debug for Slope ``` ### `fmt` ```rust fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result ``` [Source]() ## [Implementation of GapSafePenalty](<70ffed513f4897153138a3d474faab53b31c338c10fd2b0945fd39cc01a58a42>) [Source]() ```rust impl GapSafePenalty for shrinkage::Slope ``` ### `dual_feasible` ```rust fn dual_feasible( &self, correlations: &[f64], errors: &[f64] ) -> Result ``` [Source]() ### `dual_scaling` ```rust fn dual_scaling( &self, correlations: &[f64], errors: &[f64] ) -> Result, FitError> ``` [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], _: &Slope, iteration: usize ) -> Result<(), FitError<::Error>> ``` [Source]() ### `set_screened` ```rust fn set_screened(&mut self, _: &[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: &Slope, 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::Slope ``` ### `AtStrength` ```rust type AtStrength = Slope; ``` [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 Slope ``` ### `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 Slope ``` ### `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::Slope ``` ### `State` ```rust type State = State; ``` [Source]() ## Implementation of Freeze ```rust impl !Freeze for Slope ``` ## Implementation of RefUnwindSafe ```rust impl !RefUnwindSafe for Slope ``` ## Implementation of Send ```rust impl Send for Slope ``` ## Implementation of Sync ```rust impl !Sync for Slope ``` ## Implementation of Unpin ```rust impl Unpin for Slope ``` ## Implementation of UnsafeUnpin ```rust impl UnsafeUnpin for Slope ``` ## Implementation of UnwindSafe ```rust impl UnwindSafe for Slope ``` ## 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 ```