Namespace containing SLOPE regression implementation. More...

Namespaces
namespace	constants
	Namespace containing constants used in the slope library.

Classes
class	Accuracy
	Classification Accuracy scoring metric. More...

class	AUC
	Area Under the ROC Curve (AUC-ROC) scoring metric. More...

class	Clusters
	Representation of the clusters in SLOPE. More...

struct	CvConfig
	Configuration settings for cross-validation. More...

struct	CvResult
	Contains overall results from a cross-validation process. More...

class	Deviance
	Deviance scoring metric. More...

class	Folds
	Manages data partitioning for cross-validation. More...

struct	GridResult
	Stores cross-validation results for a specific set of hyperparameters. More...

class	Hybrid
	Hybrid CD-PGD solver for SLOPE. More...

class	Logistic
	The Logistic class represents a logistic loss function. More...

class	Loss
	Loss function interface. More...

class	MAE
	Mean Absolute Error (MAE) scoring metric. More...

class	MaximizeScore
	Scoring metric that aims to maximize the score value. More...

class	MinimizeScore
	Scoring metric that aims to minimize the score value. More...

class	MisClass
	Misclassification Rate scoring metric. More...

class	MSE
	Mean Squared Error (MSE) scoring metric. More...

class	Multinomial
	The Multinomial class represents a multinomial logistic regression loss function. More...

class	NoScreening
	No screening rule - uses all variables. More...

class	PGD
	Proximal Gradient Descent solver for SLOPE optimization. More...

class	Poisson
	The Poisson class represents a Poisson regression loss function. More...

class	Quadratic
	Implementation of the Quadratic loss function. More...

class	Score
	Base class for scoring metrics used in regularized generalized linear regression. More...

class	ScreeningRule
	Base class for screening rules in SLOPE. More...

class	Slope
	The SLOPE model. More...

class	SlopeFit
	A class representing the results of SLOPE (Sorted L1 Penalized Estimation) fitting. More...

class	SlopePath
	Container class for SLOPE regression solution paths. More...

class	SolverBase
	Abstract base class for SLOPE optimization solvers. More...

class	SortedL1Norm
	Class representing the Sorted L1 Norm. More...

class	StrongScreening
	Implements strong screening rules for SLOPE. More...

class	Threads
	Manages OpenMP thread settings across libslope. More...

class	Timer
	Timer class for measuring elapsed time with high resolution. More...

struct	Warning
	Structure representing a warning with its code and message. More...

class	WarningLogger
	Thread-safe warning logger for tracking runtime warnings. More...

Enumerations
enum class	JitNormalization { None = 0 , Center = 1 , Scale = 2 , Both = 3 }
	Enums to control predictor standardization behavior. More...

enum class	WarningCode { GENERIC_WARNING , DEPRECATED_FEATURE , MAXIT_REACHED , LINE_SEARCH_FAILED }
	Standard warning codes used throughout the slope library. More...

Functions
Eigen::SparseMatrix< int >	patternMatrix (const Eigen::VectorXd &beta)
	Returns the cluster pattern as a sparse matrix.

template<typename T >
CvResult	crossValidate (Slope model, Eigen::EigenBase< T > &x, const Eigen::MatrixXd &y_in, const CvConfig &config=CvConfig())
	Performs cross-validation on a SLOPE model to select optimal hyperparameters.

template<typename MatrixType >
double	computeDual (const Eigen::VectorXd &beta, const Eigen::MatrixXd &residual, const std::unique_ptr< Loss > &loss, const SortedL1Norm &sl1_norm, const Eigen::ArrayXd &lambda, const MatrixType &x, const Eigen::MatrixXd &y, const Eigen::VectorXd &x_centers, const Eigen::VectorXd &x_scales, const JitNormalization &jit_normalization, const bool intercept)
	Computes the dual objective function value for SLOPE optimization.

template<typename T >
double	estimateNoise (Eigen::EigenBase< T > &x, Eigen::MatrixXd &y, const bool fit_intercept)
	Estimates noise (standard error) in a linear model using OLS residuals.

std::string	warningCodeToString (WarningCode code)
	Convert a warning code to its string representation.

std::unique_ptr< Loss >	setupLoss (const std::string &loss)
	Factory function to create the appropriate loss function based on the distribution family.

template<typename T >
int	sign (T val)
	Returns the sign of a given value.

template<typename T >
Eigen::ArrayXd	cumSum (const T &x, const bool leading_zero=false)

template<typename T >
T	sigmoid (const T &x)

template<typename T >
T	logit (const T &x)

template<typename T >
T	clamp (const T &x, const T &lo, const T &hi)

Eigen::VectorXd	logSumExp (const Eigen::MatrixXd &a)

Eigen::MatrixXd	softmax (const Eigen::MatrixXd &x)

template<typename T >
Eigen::MatrixXd	linearPredictor (const T &x, const std::vector< int > &active_set, const Eigen::VectorXd &beta0, const Eigen::VectorXd &beta, const Eigen::VectorXd &x_centers, const Eigen::VectorXd &x_scales, const JitNormalization jit_normalization, const bool intercept)

template<typename T >
void	updateGradient (Eigen::VectorXd &gradient, const T &x, const Eigen::MatrixXd &residual, const std::vector< int > &active_set, const Eigen::VectorXd &x_centers, const Eigen::VectorXd &x_scales, const Eigen::VectorXd &w, const JitNormalization jit_normalization)

template<typename T >
void	offsetGradient (Eigen::VectorXd &gradient, const T &x, const Eigen::VectorXd &offset, const std::vector< int > &active_set, const Eigen::VectorXd &x_centers, const Eigen::VectorXd &x_scales, const JitNormalization jit_normalization)

std::vector< int >	setUnion (const std::vector< int > &a, const std::vector< int > &b)
	Computes the union of two sorted integer vectors.

std::vector< int >	setDiff (const std::vector< int > &a, const std::vector< int > &b)
	Computes the set difference of two sorted integer vectors.

template<typename T >
int	whichMax (const T &x)
	Returns the index of the maximum element in a container.

template<typename T >
int	whichMin (const T &x)
	Returns the index of the minimum element in a container.

template<typename T , typename Comparator >
int	whichBest (const T &x, const Comparator &comp)
	Returns the index of the minimum element in a container.

Eigen::ArrayXd	geomSpace (const double start, const double end, const int n)
	Creates an array of n numbers in geometric progression from start to end.

template<typename T >
Eigen::VectorXd	l1Norms (const T &x)
	Computes the L1 (Manhattan) norms for each column of a matrix.

template<typename T >
Eigen::VectorXd	l2Norms (const Eigen::SparseMatrixBase< T > &x)
	Computes the L2 (Euclidean) norms for each column of a sparse matrix.

template<typename T >
Eigen::VectorXd	l2Norms (const Eigen::MatrixBase< T > &x)
	Computes the L2 (Euclidean) norms for each column of a dense matrix.

template<typename T >
Eigen::VectorXd	maxAbs (const Eigen::SparseMatrixBase< T > &x)
	Computes the maximum absolute value for each column of a matrix.

template<typename T >
Eigen::VectorXd	maxAbs (const Eigen::MatrixBase< T > &x)
	Computes the maximum absolute value for each column of a dense matrix.

template<typename T >
Eigen::VectorXd	means (const Eigen::SparseMatrixBase< T > &x)
	Computes the arithmetic mean for each column of a sparse matrix.

template<typename T >
Eigen::VectorXd	means (const Eigen::MatrixBase< T > &x)
	Computes the arithmetic mean for each column of a dense matrix.

template<typename T >
Eigen::VectorXd	stdDevs (const Eigen::SparseMatrixBase< T > &x)
	Computes the standard deviation for each column of a matrix.

template<typename T >
Eigen::VectorXd	stdDevs (const Eigen::MatrixBase< T > &x)
	Computes the standard deviation for each column of a matrix.

template<typename T >
Eigen::VectorXd	ranges (const Eigen::SparseMatrixBase< T > &x)
	Computes the range (max - min) for each column of a matrix.

template<typename T >
Eigen::VectorXd	ranges (const Eigen::MatrixBase< T > &x)
	Computes the range (max - min) for each column of a dense matrix.

template<typename T >
Eigen::VectorXd	mins (const Eigen::SparseMatrixBase< T > &x)
	Computes the minimum value for each column of a sparse matrix.

template<typename T >
Eigen::VectorXd	mins (const Eigen::MatrixBase< T > &x)
	Computes the minimum value for each column of a dense matrix.

template<typename T >
Eigen::VectorXd	clusterGradient (Eigen::VectorXd &beta, Eigen::MatrixXd &residual, Clusters &clusters, const T &x, const Eigen::MatrixXd &w, const Eigen::VectorXd &x_centers, const Eigen::VectorXd &x_scales, const JitNormalization jit_normalization)

template<typename T >
void	computeCenters (Eigen::VectorXd &x_centers, const T &x, const std::string &type)

template<typename T >
void	computeScales (Eigen::VectorXd &x_scales, const T &x, const std::string &type)

template<typename T >
JitNormalization	normalize (Eigen::MatrixBase< T > &x, Eigen::VectorXd &x_centers, Eigen::VectorXd &x_scales, const std::string &centering_type, const std::string &scaling_type, const bool modify_x)

template<typename T >
JitNormalization	normalize (Eigen::SparseMatrixBase< T > &x, Eigen::VectorXd &x_centers, Eigen::VectorXd &x_scales, const std::string &centering_type, const std::string &scaling_type, const bool)

std::tuple< Eigen::VectorXd, Eigen::MatrixXd >	rescaleCoefficients (const Eigen::VectorXd &beta0, const Eigen::SparseMatrix< double > &beta, const Eigen::VectorXd &x_centers, const Eigen::VectorXd &x_scales, const bool intercept)
	Rescales the coefficients using the given parameters.

Eigen::ArrayXd	lambdaSequence (const int p, const double q, const std::string &type, const int n=-1, const double theta1=1.0, const double theta2=1.0)

Eigen::ArrayXd	regularizationPath (const Eigen::ArrayXd &alpha_in, const int path_length, double alpha_min_ratio, const double alpha_max)

double	binaryRocAuc (const Eigen::VectorXd &scores, const Eigen::VectorXd &labels)

double	rocAuc (const Eigen::MatrixXd &scores, const Eigen::MatrixXd &labels)

std::vector< int >	activeSet (const Eigen::VectorXd &beta)
	Identifies previously active variables.

std::vector< int >	strongSet (const Eigen::VectorXd &gradient_prev, const Eigen::ArrayXd &lambda, const Eigen::ArrayXd &lambda_prev)
	Determines the strong set using sequential strong rules.

std::unique_ptr< ScreeningRule >	createScreeningRule (const std::string &screening_type)
	Creates a screening rule based on the provided type.

bool	defaultInterruptChecker ()
	Default no-op interrupt checker.

template<typename T >
std::pair< double, double >	computeGradientAndHessian (const T &x, const int ind, const Eigen::MatrixXd &w, const Eigen::MatrixXd &residual, const Eigen::VectorXd &x_centers, const Eigen::VectorXd &x_scales, const double s, const JitNormalization jit_normalization, const int n)

template<typename T >
std::pair< double, double >	computeClusterGradientAndHessian (const Eigen::MatrixBase< T > &x, const int c_ind, const std::vector< int > &s, const Clusters &clusters, const Eigen::MatrixXd &w, const Eigen::MatrixXd &residual, const Eigen::VectorXd &x_centers, const Eigen::VectorXd &x_scales, const JitNormalization jit_normalization)

template<typename T >
std::pair< double, double >	computeClusterGradientAndHessian (const Eigen::SparseMatrixBase< T > &x, const int c_ind, const std::vector< int > &s, const Clusters &clusters, const Eigen::MatrixXd &w, const Eigen::MatrixXd &residual, const Eigen::VectorXd &x_centers, const Eigen::VectorXd &x_scales, const JitNormalization jit_normalization)

template<typename T >
double	coordinateDescent (Eigen::VectorXd &beta0, Eigen::VectorXd &beta, Eigen::MatrixXd &residual, Clusters &clusters, const Eigen::ArrayXd &lambda_cumsum, const T &x, const Eigen::MatrixXd &w, const Eigen::VectorXd &x_centers, const Eigen::VectorXd &x_scales, const bool intercept, const JitNormalization jit_normalization, const bool update_clusters, std::mt19937 &rng, const std::string &cd_type="cyclical")

std::unique_ptr< SolverBase >	setupSolver (const std::string &solver_type, const std::string &loss, JitNormalization jit_normalization, bool intercept, bool update_clusters, int cd_iterations, const std::string &cd_type, std::optional< int > random_seed=std::nullopt)
	Factory function to create and configure a SLOPE solver.

std::tuple< double, int >	slopeThreshold (const double x, const int j, const Eigen::ArrayXd &lambda_cumsum, const Clusters &clusters)

template<typename Derived >
Eigen::Index	nonZeros (const Eigen::SparseMatrixBase< Derived > &x)

template<typename Derived >
Eigen::Index	nonZeros (const Eigen::DenseBase< Derived > &x)

template<typename T >
void	sort (T &v, const bool descending=false)

template<typename T >
std::vector< int >	which (const T &x)

template<typename T >
std::vector< int >	sortIndex (T &v, const bool descending=false)

template<typename T >
void	permute (T &values, const std::vector< int > &ind)

template<typename T >
void	inversePermute (T &values, const std::vector< int > &ind)

template<typename T >
void	move_elements (std::vector< T > &v, const int from, const int to, const int size)

void	validateOption (const std::string &value, const std::set< std::string > &valid_options, const std::string &parameter_name)
	Validates if a given value exists in a set of valid options.

template<typename T >
T	subset (const Eigen::EigenBase< T > &x, const std::vector< int > &indices)
	Extract a subset of rows from an Eigen matrix.

template<typename T >
Eigen::MatrixBase< T >::PlainObject	subset (const Eigen::DenseBase< T > &x, const std::vector< int > &indices)
	Extract a subset of rows from an Eigen matrix.

template<typename T >
T	subset (const Eigen::SparseMatrixBase< T > &x, const std::vector< int > &indices)
	Extract a subset of rows from a sparse Eigen matrix.

template<typename T >
T	subsetCols (const Eigen::MatrixBase< T > &x, const std::vector< int > &indices)
	Extract specified columns from a dense matrix.

template<typename T >
T	subsetCols (const Eigen::SparseMatrixBase< T > &x, const std::vector< int > &indices)

std::unordered_set< double >	unique (const Eigen::MatrixXd &x)
	Create a set of unique values from an Eigen matrix.

Detailed Description

Namespace containing SLOPE regression implementation.

Enumeration Type Documentation

◆ JitNormalization

enum class slope::JitNormalization

strong

Enums to control predictor standardization behavior.

Enumerator
None	No JIT normalization.
Center	Center JIT.
Scale	Scale JIT.
Both	Both.

Definition at line 12 of file jit_normalization.h.

◆ WarningCode

enum class slope::WarningCode

strong

Standard warning codes used throughout the slope library.

These enum values represent the various types of warnings that can be generated during computational operations.

Enumerator
GENERIC_WARNING	General uncategorized warning.
DEPRECATED_FEATURE	Feature marked for deprecation.
MAXIT_REACHED	Maximum iterations reached without convergence.
LINE_SEARCH_FAILED	Line search algorithm failed to converge.

Definition at line 25 of file logger.h.

Function Documentation

◆ activeSet()

std::vector< int > slope::activeSet ( const Eigen::VectorXd & beta )

Identifies previously active variables.

Parameters

beta	Current coefficient matrix

Returns: std::vector<int> Indices of variables with non-zero coefficients

◆ binaryRocAuc()

double slope::binaryRocAuc	(	const Eigen::VectorXd &	scores,
		const Eigen::VectorXd &	labels
	)

Computes the Area Under the ROC Curve (AUC-ROC) for binary classification.

Parameters

scores	Vector of prediction scores/probabilities for each sample
labels	Vector of true binary labels (0 or 1)

Returns: The AUC-ROC score between 0 and 1, where 1 indicates perfect prediction and 0.5 indicates random prediction

Both input vectors must have the same length. The function calculates how well the scores discriminate between the positive and negative classes.

◆ clamp()

template<typename T >

T slope::clamp	(	const T &	x,
		const T &	lo,
		const T &	hi
	)

Returns the value of x clamped between the specified lower and upper bounds.

Template Parameters

T	the type of the values being clamped

Parameters

x	the value to be clamped
lo	the lower bound
hi	the upper bound

Returns: the clamped value of x

Definition at line 112 of file math.h.

◆ clusterGradient()

template<typename T >

Eigen::VectorXd slope::clusterGradient	(	Eigen::VectorXd &	beta,
		Eigen::MatrixXd &	residual,
		Clusters &	clusters,
		const T &	x,
		const Eigen::MatrixXd &	w,
		const Eigen::VectorXd &	x_centers,
		const Eigen::VectorXd &	x_scales,
		const JitNormalization	jit_normalization
	)

Computes the gradient for clustered variables.

This function calculates the gradient of the loss function with respect to the clustered coefficients, taking into account the cluster structure where multiple variables may have the same coefficient magnitude.

Parameters

beta	Current coefficient vector (modified in-place)
residual	Current residual matrix (modified in-place)
clusters	Cluster information object containing variable groupings
x	Input feature matrix
w	Weight matrix for observations
x_centers	Vector of feature centers (means) for normalization
x_scales	Vector of feature scales (standard deviations) for normalization
jit_normalization	Normalization strategy applied to features

Returns: Gradient vector with respect to cluster coefficients

Definition at line 804 of file math.h.

◆ computeCenters()

template<typename T >

void slope::computeCenters	(	Eigen::VectorXd &	x_centers,
		const T &	x,
		const std::string &	type
	)

Compute centers.

There are two supported centering types:

"none": Do not compute centers and scales.
"mean": Use arithmetic means.

Template Parameters

T	The type of the input matrix.

Parameters

x_centers	A vector where the computed or provided centers will be stored.
x	The input matrix.
type	A string specifying the normalization type ("none", "manual", or "standardization").

Exceptions

std::invalid_argument if the provided manual centers or scales have invalid dimensions or contain non-finite values.

Definition at line 33 of file normalize.h.

◆ computeClusterGradientAndHessian() [1/2]

template<typename T >

std::pair< double, double > slope::computeClusterGradientAndHessian	(	const Eigen::MatrixBase< T > &	x,
		const int	c_ind,
		const std::vector< int > &	s,
		const Clusters &	clusters,
		const Eigen::MatrixXd &	w,
		const Eigen::MatrixXd &	residual,
		const Eigen::VectorXd &	x_centers,
		const Eigen::VectorXd &	x_scales,
		const JitNormalization	jit_normalization
	)

Computes the gradient and Hessian for a cluster of variables in coordinate descent.

This function handles the case when multiple variables are in the same cluster (have the same coefficient magnitude), calculating the combined gradient and Hessian needed for the coordinate descent update.

Parameters

x	Input matrix
c_ind	Cluster index
s	Vector of signs for each variable in the cluster
clusters	The cluster information object
w	Weights
residual	Residual vector
x_centers	Vector of feature centers (means)
x_scales	Vector of feature scales (standard deviations)
jit_normalization	Normalization strategy (Both, Center, Scale, or None)

Returns

std::pair<double, double> containing:

first: Hessian of the loss function for the cluster
second: gradient of the loss function for the cluster

Definition at line 127 of file hybrid_cd.h.

◆ computeClusterGradientAndHessian() [2/2]

template<typename T >

std::pair< double, double > slope::computeClusterGradientAndHessian	(	const Eigen::SparseMatrixBase< T > &	x,
		const int	c_ind,
		const std::vector< int > &	s,
		const Clusters &	clusters,
		const Eigen::MatrixXd &	w,
		const Eigen::MatrixXd &	residual,
		const Eigen::VectorXd &	x_centers,
		const Eigen::VectorXd &	x_scales,
		const JitNormalization	jit_normalization
	)

Computes the gradient and Hessian for a cluster of variables in coordinate descent (sparse matrix version).

This overloaded version handles sparse input matrices, optimizing the computation for this data structure.

Parameters

x	Input sparse matrix
c_ind	Cluster index
s	Vector of signs for each variable in the cluster
clusters	The cluster information object
w	Vector of weights
residual	Residual vector
x_centers	Vector of feature centers (means)
x_scales	Vector of feature scales (standard deviations)
jit_normalization	Normalization strategy (Both, Center, Scale, or None)

Returns

std::pair<double, double> containing:

first: Hessian of the loss function for the cluster
second: gradient of the loss function for the cluster

Definition at line 207 of file hybrid_cd.h.

◆ computeDual()

template<typename MatrixType >

double slope::computeDual	(	const Eigen::VectorXd &	beta,
		const Eigen::MatrixXd &	residual,
		const std::unique_ptr< Loss > &	loss,
		const SortedL1Norm &	sl1_norm,
		const Eigen::ArrayXd &	lambda,
		const MatrixType &	x,
		const Eigen::MatrixXd &	y,
		const Eigen::VectorXd &	x_centers,
		const Eigen::VectorXd &	x_scales,
		const JitNormalization &	jit_normalization,
		const bool	intercept
	)

Computes the dual objective function value for SLOPE optimization.

Template Parameters

MatrixType The type of the design matrix

Parameters

beta	Current coefficient vector
residual	Residual matrix (y - prediction)
loss	Pointer to the loss function object
sl1_norm	Sorted L1 norm object
lambda	Vector of penalty parameters
x	Design matrix
y	Response matrix
x_centers	Vector of feature means for centering
x_scales	Vector of feature scales for normalization
jit_normalization	Just-in-time normalization settings
intercept	Boolean indicating if intercept is included in the model

Returns: double The computed dual objective value

This function computes the dual objective value for the SLOPE optimization problem. It handles both cases with and without intercept terms, applying appropriate normalization and gradient computations.

Definition at line 41 of file diagnostics.h.

◆ computeGradientAndHessian()

template<typename T >

std::pair< double, double > slope::computeGradientAndHessian	(	const T &	x,
		const int	ind,
		const Eigen::MatrixXd &	w,
		const Eigen::MatrixXd &	residual,
		const Eigen::VectorXd &	x_centers,
		const Eigen::VectorXd &	x_scales,
		const double	s,
		const JitNormalization	jit_normalization,
		const int	n
	)

Computes the gradient and Hessian for coordinate descent optimization with different normalization strategies.

Template Parameters

T	Matrix type (expected to support col() operations like Eigen matrices)

Parameters

x	Input matrix
ind	Column index to compute derivatives for
w	Vector of weights
residual	Residual vector
x_centers	Vector of feature centers (means)
x_scales	Vector of feature scales (standard deviations)
s	Step size parameter
jit_normalization	Normalization strategy (Both, Center, Scale, or None)
n	Number of samples

Returns

std::pair<double, double> containing:

first: gradient of the loss function
second: diagonal Hessian element

Definition at line 43 of file hybrid_cd.h.

◆ computeScales()

template<typename T >

void slope::computeScales	(	Eigen::VectorXd &	x_scales,
		const T &	x,
		const std::string &	type
	)

Compute scales

There are two supported scaling types:

"none": Do not compute centers and scales.
"sd": Compute centers and scales using Welford’s algorithm.

Template Parameters

T	The type of the input matrix.

Parameters

x	The input matrix.
x_scales	A vector where the computed or provided scales will be stored.
type	A string specifying the normalization type ("none", "manual", or "standardization").

Exceptions

std::invalid_argument if the provided manual centers or scales have invalid dimensions or contain non-finite values.

Definition at line 74 of file normalize.h.

◆ coordinateDescent()

template<typename T >

double slope::coordinateDescent	(	Eigen::VectorXd &	beta0,
		Eigen::VectorXd &	beta,
		Eigen::MatrixXd &	residual,
		Clusters &	clusters,
		const Eigen::ArrayXd &	lambda_cumsum,
		const T &	x,
		const Eigen::MatrixXd &	w,
		const Eigen::VectorXd &	x_centers,
		const Eigen::VectorXd &	x_scales,
		const bool	intercept,
		const JitNormalization	jit_normalization,
		const bool	update_clusters,
		std::mt19937 &	rng,
		const std::string &	cd_type = `"cyclical"`
	)

Coordinate Descent Step

This function takes a coordinate descent step in the hybrid CD/PGD algorithm for SLOPE.

Template Parameters

T	The type of the design matrix. This can be either a dense or sparse.

Parameters

beta0	The intercept
beta	The coefficients
residual	The residual vector
clusters	The cluster information, stored in a Cluster object.
lambda_cumsum	Cumulative sum of the lambda sequence.
x	The design matrix
w	Working weights
x_centers	The center values of the data matrix columns
x_scales	The scale values of the data matrix columns
intercept	Shuold an intervept be fit?
jit_normalization	Type o fJIT normalization.
rng	Random number generator for shuffling indices in permuted CD.
update_clusters	Flag indicating whether to update the clusters after each uupdate.
cd_type	Type of coordinate descent to use ("cyclical" or "permuted")

See also: Clusters; SortedL1Norm; JitNormalization

Definition at line 332 of file hybrid_cd.h.

◆ createScreeningRule()

std::unique_ptr< ScreeningRule > slope::createScreeningRule ( const std::string & screening_type )

Creates a screening rule based on the provided type.

Parameters

screening_type Type of screening rule to create ("none" or "strong")

Returns: std::unique_ptr<ScreeningRule> A pointer to the created screening rule

◆ crossValidate()

template<typename T >

CvResult slope::crossValidate	(	Slope	model,
		Eigen::EigenBase< T > &	x,
		const Eigen::MatrixXd &	y_in,
		const CvConfig &	config = `CvConfig()`
	)

Performs cross-validation on a SLOPE model to select optimal hyperparameters.

Template Parameters

T	Type of design matrix (supports both dense and sparse matrices)

Parameters

model	The SLOPE model to be cross-validated
x	The design matrix containing predictors
y_in	The response matrix
config	Configuration parameters for cross-validation (optional)

Returns: CvResult Object containing cross-validation results, including best parameters, regularization paths, and performance metrics across folds

This function implements k-fold cross-validation for SLOPE models, evaluating model performance across a grid of hyperparameters. For each hyperparameter combination, the function:

Splits the data into training and validation sets according to the fold configuration
Fits the model on each training set and evaluates on the validation set
Computes the specified evaluation metric for each regularization parameter
Averages results across folds to select optimal hyperparameters

The function supports parallel processing with OpenMP when available.

Definition at line 248 of file cv.h.

◆ cumSum()

template<typename T >

Eigen::ArrayXd slope::cumSum	(	const T &	x,
		const bool	leading_zero = `false`
	)

Calculates the cumulative sum of the elements in the input array.

Template Parameters

T	The type of the input array.

Parameters

x	The input array.
leading_zero	If true, the output array will have an additional leading

Returns: An Eigen::ArrayXd containing the cumulative sum of the elements in the input array.

Definition at line 53 of file math.h.

◆ defaultInterruptChecker()

bool slope::defaultInterruptChecker ( )

inline

Default no-op interrupt checker.

Returns: Always returns false

Definition at line 42 of file slope.h.

◆ estimateNoise()

template<typename T >

double slope::estimateNoise	(	Eigen::EigenBase< T > &	x,
		Eigen::MatrixXd &	y,
		const bool	fit_intercept
	)

Estimates noise (standard error) in a linear model using OLS residuals.

Calculates the standard error of the residuals from an Ordinary Least Squares (OLS) regression. This is computed as sqrt(sum(residuals²) / (n - p + intercept_term)), where n is the number of observations and p is the number of predictors.

Template Parameters

MatrixType The type of matrix used to store the design matrix

Parameters

x	Design matrix with n observations and p predictors
y	Response matrix
fit_intercept	Whether to include an intercept term in the model

Returns: The estimated noise level (standard error of residuals)

Definition at line 29 of file estimate_alpha.h.

◆ geomSpace()

Eigen::ArrayXd slope::geomSpace	(	const double	start,
		const double	end,
		const int	n
	)

Creates an array of n numbers in geometric progression from start to end.

Parameters

start	The starting value of the sequence
end	The final value of the sequence
n	The number of points to generate

Returns: Eigen::ArrayXd Array containing n points spaced geometrically between start and end

Note: Similar to numpy.geomspace, generates points that are evenly spaced on a log scale

Exceptions

std::invalid_argument If start or end is zero, or if n < 1

◆ inversePermute()

template<typename T >

void slope::inversePermute	(	T &	values,
		const std::vector< int > &	ind
	)

Inverse permutes the elements of a container based on the given indices.

This function takes a container of values and a vector of indices and rearranges the elements of the container according to the indices. The resulting container will have the elements in the order specified by the indices.

Template Parameters

T	The type of the container.

Parameters

values	The container of values to be permuted.
ind	The vector of indices specifying the new order of the elements.

< The resulting container after permutation.

Definition at line 186 of file utils.h.

◆ l1Norms()

template<typename T >

Eigen::VectorXd slope::l1Norms ( const T & x )

Computes the L1 (Manhattan) norms for each column of a matrix.

Template Parameters

T	Matrix type (must support cols(), col() operations, compatible with Eigen)

Parameters

x	Input matrix whose column L1 norms are to be computed

Returns: Eigen::VectorXd Vector containing L1 norms of each column

For each column j in matrix x, computes the L1 norm:

\[ \|x_j\|_1 = \sum_{i} |x_{ij}| \]

where x_{ij} represents the i-th element of the j-th column.

Definition at line 453 of file math.h.

◆ l2Norms() [1/2]

template<typename T >

Eigen::VectorXd slope::l2Norms ( const Eigen::MatrixBase< T > & x )

Computes the L2 (Euclidean) norms for each column of a dense matrix.

Parameters

x	Input dense matrix whose column L2 norms are to be computed

Returns: Eigen::VectorXd Vector containing L2 norms of each column

For each column j in matrix x, computes the L2 norm:

\[ \|x_j\|_2 = \sqrt{\sum_{i} x_{ij}^2} \]

where x_{ij} represents the i-th element of the j-th column.

Definition at line 503 of file math.h.

◆ l2Norms() [2/2]

template<typename T >

Eigen::VectorXd slope::l2Norms ( const Eigen::SparseMatrixBase< T > & x )

Computes the L2 (Euclidean) norms for each column of a sparse matrix.

Parameters

x	Input sparse matrix whose column L2 norms are to be computed

Returns: Eigen::VectorXd Vector containing L2 norms of each column

For each column j in matrix x, computes the L2 norm:

\[ \|x_j\|_2 = \sqrt{\sum_{i} x_{ij}^2} \]

where x_{ij} represents the i-th element of the j-th column.

Definition at line 478 of file math.h.

◆ lambdaSequence()

Eigen::ArrayXd slope::lambdaSequence	(	const int	p,
		const double	q,
		const std::string &	type,
		const int	n = `-1`,
		const double	theta1 = `1.0`,
		const double	theta2 = `1.0`
	)

Generates a sequence of regularization weights for the sorted L1 norm.

Parameters

p	The number of lambda values to generate (number of features)
q	The false discovery rate (FDR) level or quantile value (in (0, 1))
type	The type of sequence to generate: "bh": Benjamini-Hochberg sequence "gaussian": Gaussian sequence "oscar": Octagonal Shrinkage and Clustering Algorithm for Regression
n	Number of observations (only used for gaussian type)
theta1	First parameter for OSCAR weights (default: 1.0)
theta2	Second parameter for OSCAR weights (default: 1.0)

Returns: Eigen::ArrayXd containing the generated lambda sequence in decreasing order

◆ linearPredictor()

template<typename T >

Eigen::MatrixXd slope::linearPredictor	(	const T &	x,
		const std::vector< int > &	active_set,
		const Eigen::VectorXd &	beta0,
		const Eigen::VectorXd &	beta,
		const Eigen::VectorXd &	x_centers,
		const Eigen::VectorXd &	x_scales,
		const JitNormalization	jit_normalization,
		const bool	intercept
	)

Computes the gradient of the loss with respect to \(\beta\).

Template Parameters

T	The type of the input matrix.

Parameters

x	The input matrix.
active_set	Indicies for active set
beta0	Intercept
beta	Coefficients
x_centers	The vector of center values for each column of x.
x_scales	The vector of scale values for each column of x.
jit_normalization	Type of JIT normalization.
intercept	Whether to fit an intercept.

Returns: The computed gradient vector.

Definition at line 153 of file math.h.

◆ logit()

template<typename T >

T slope::logit ( const T & x )

The logit

The logit function is defined as \(\log(\frac{x}{1 - x})\).

Template Parameters

T	The type of the input.

Parameters

x	The input value.

Returns: The result of the logit function.

Definition at line 94 of file math.h.

◆ logSumExp()

Eigen::VectorXd slope::logSumExp ( const Eigen::MatrixXd & a )

LogSumExp

Parameters

a A matrix

Returns: \(\log(\sum_i \exp(a_i))\)

◆ maxAbs() [1/2]

template<typename T >

Eigen::VectorXd slope::maxAbs ( const Eigen::MatrixBase< T > & x )

Computes the maximum absolute value for each column of a dense matrix.

Parameters

x	Input dense matrix whose column-wise maximum absolute values are to be computed

Returns: Eigen::VectorXd Vector containing the maximum absolute value of each column

For each column j in matrix x, computes:

\[ \max_{i} |x_{ij}| \]

where x_{ij} represents the i-th element of the j-th column.

Definition at line 554 of file math.h.

◆ maxAbs() [2/2]

template<typename T >

Eigen::VectorXd slope::maxAbs ( const Eigen::SparseMatrixBase< T > & x )

Computes the maximum absolute value for each column of a matrix.

Parameters

x	Input matrix to compute column-wise maximum absolute values

Returns: Eigen::VectorXd Vector containing maximum absolute values for each column

For each column j in matrix x, computes:

\[ \max_{i} |x_{ij}| \]

where x_{ij} represents the i-th element of the j-th column.

Definition at line 521 of file math.h.

◆ means() [1/2]

template<typename T >

Eigen::VectorXd slope::means ( const Eigen::MatrixBase< T > & x )

Computes the arithmetic mean for each column of a dense matrix.

Parameters

x	Input dense matrix whose column means are to be computed

Returns: Eigen::VectorXd Vector containing the arithmetic mean of each column

For each column j in matrix x, computes the mean:

\[ \bar{x}_j = \frac{1}{n}\sum_{i} x_{ij} \]

where n is the number of rows in the matrix and x_{ij} represents the i-th element of the j-th column.

Definition at line 599 of file math.h.

◆ means() [2/2]

template<typename T >

Eigen::VectorXd slope::means ( const Eigen::SparseMatrixBase< T > & x )

Computes the arithmetic mean for each column of a sparse matrix.

Parameters

x	Input sparse matrix whose column means are to be computed

Returns: Eigen::VectorXd Vector containing the arithmetic mean of each column

For each column j in matrix x, computes the mean:

\[ \bar{x}_j = \frac{1}{n}\sum_{i} x_{ij} \]

where n is the number of rows in the matrix and x_{ij} represents the i-th element of the j-th column.

Definition at line 572 of file math.h.

◆ mins() [1/2]

template<typename T >

Eigen::VectorXd slope::mins ( const Eigen::MatrixBase< T > & x )

Computes the minimum value for each column of a dense matrix.

Parameters

x	Input dense matrix whose column minimums are to be computed

Returns: Eigen::VectorXd Vector containing the minimum value of each column

For each column j in matrix x, computes:

\[ \min_{i}(x_{ij}) \]

where x_{ij} represents the i-th element of the j-th column.

Uses Eigen's built-in column-wise operations for efficient computation on dense matrices.

Definition at line 779 of file math.h.

◆ mins() [2/2]

template<typename T >

Eigen::VectorXd slope::mins ( const Eigen::SparseMatrixBase< T > & x )

Computes the minimum value for each column of a sparse matrix.

Parameters

x	Input sparse matrix whose column minimums are to be computed

Returns: Eigen::VectorXd Vector containing the minimum value of each column

For each column j in matrix x, computes:

\[ \min_{i}(x_{ij}) \]

where x_{ij} represents the i-th element of the j-th column.

Definition at line 745 of file math.h.

◆ move_elements()

template<typename T >

void slope::move_elements	(	std::vector< T > &	v,
		const int	from,
		const int	to,
		const int	size
	)

Moves a range of elements within a vector.

This function moves a range of elements within a vector from one position to another. The elements are moved in a way that the order is preserved.

Template Parameters

T	The type of elements in the vector.

Parameters

v	The vector containing the elements.
from	The starting index of the range to be moved.
to	The ending index of the range to be moved.
size	The size of the range to be moved.

Definition at line 210 of file utils.h.

◆ nonZeros() [1/2]

template<typename Derived >

Eigen::Index slope::nonZeros ( const Eigen::DenseBase< Derived > & x )

Count non-zero elements in a dense matrix.

Parameters

x	Dense matrix

Returns: Number of non-zero elements

Definition at line 46 of file utils.h.

◆ nonZeros() [2/2]

template<typename Derived >

Eigen::Index slope::nonZeros ( const Eigen::SparseMatrixBase< Derived > & x )

Count non-zero elements in a matrix.

Helper function for Eigen matrices since nonZeros() was removed from dense matrices in Eigen 5.0.0, but still exists for sparse matrices.

Parameters

x	Sparse matrix

Returns: Number of non-zero elements

Definition at line 33 of file utils.h.

◆ normalize() [1/2]

template<typename T >

JitNormalization slope::normalize	(	Eigen::MatrixBase< T > &	x,
		Eigen::VectorXd &	x_centers,
		Eigen::VectorXd &	x_scales,
		const std::string &	centering_type,
		const std::string &	scaling_type,
		const bool	modify_x
	)

Normalize a dense matrix by centering and scaling.

The function computes column centers and scaling factors based on the specified normalization type ("none", "manual", or "standardization"). If modify_x is true, the normalization is applied directly to the input matrix.

Parameters

x	The dense input matrix to be normalized.
x_centers	A vector that will hold the column centers. It will be resized to match the number of columns.
x_scales	A vector that will hold the column scaling factors. It will be resized to match the number of columns.
centering_type	A string specifying the normalization type ("none", "manual", or "standardization").
scaling_type	A string specifying the normalization type ("none", "manual", or "standardization").
modify_x	If true, modifies x in-place; otherwise, x remains unchanged (centers/scales are still computed).

Returns: true if normalization succeeds, false otherwise.

Definition at line 123 of file normalize.h.

◆ normalize() [2/2]

template<typename T >

JitNormalization slope::normalize	(	Eigen::SparseMatrixBase< T > &	x,
		Eigen::VectorXd &	x_centers,
		Eigen::VectorXd &	x_scales,
		const std::string &	centering_type,
		const std::string &	scaling_type,
		const bool
	)

Normalize a sparse matrix by scaling only.

To preserve sparsity, centering is not applied. The scaling factors for each column are computed according to the specified normalization type ("none", "manual", or "standardization"). If modify_x is true, the scaling is applied directly to the input matrix.

Parameters

x	The sparse input matrix to be normalized.
x_centers	A vector that will hold the column centers. For sparse matrices, centering is typically skipped; this parameter is maintained for consistency.
x_scales	A vector that will hold the column scaling factors. It will be resized to match the number of columns.
centering_type	A string specifying the normalization type ("none", "manual", or "standardization").
scaling_type	A string specifying the normalization type ("none", "manual", or "standardization").

Returns: true if normalization succeeds, false otherwise.

Definition at line 199 of file normalize.h.

◆ offsetGradient()

template<typename T >

void slope::offsetGradient	(	Eigen::VectorXd &	gradient,
		const T &	x,
		const Eigen::VectorXd &	offset,
		const std::vector< int > &	active_set,
		const Eigen::VectorXd &	x_centers,
		const Eigen::VectorXd &	x_scales,
		const JitNormalization	jit_normalization
	)

Computes the gradient of the loss with respect to \(\beta\).

Template Parameters

T	The type of the input matrix.

Parameters

gradient	The residual vector.
x	The input matrix.
offset	Gradient offset
active_set	Indices for the active_set
x_centers	The vector of center values for each column of x.
x_scales	The vector of scale values for each column of x.
jit_normalization	Type of JIT normalization just-in-time.

Definition at line 306 of file math.h.

◆ patternMatrix()

Eigen::SparseMatrix< int > slope::patternMatrix ( const Eigen::VectorXd & beta )

Returns the cluster pattern as a sparse matrix.

Parameters

beta	The beta vector used to create the clusters

Returns: A sparse matrix, where the indices of column j are the indices of the features in cluster j. The matrix is of size \(p \times (m - 1)\), where \(p\) is the number of features and \(m\) is the number of clusters. The features of the zero cluster are not included.

◆ permute()

template<typename T >

void slope::permute	(	T &	values,
		const std::vector< int > &	ind
	)

Permutes the elements of a container according to the given indices.

This function takes a container of values and permutes its elements according to the given indices. The indices specify the new order of the elements in the container.

Template Parameters

T	The type of the container.

Parameters

values	The container of values to be permuted.
ind	The vector of indices specifying the new order of the elements.

The container to store the permuted values.

Permute the values according to the given indices.

Assign the permuted values back to the original container.

Definition at line 152 of file utils.h.

◆ ranges() [1/2]

template<typename T >

Eigen::VectorXd slope::ranges ( const Eigen::MatrixBase< T > & x )

Computes the range (max - min) for each column of a dense matrix.

Parameters

x	Input dense matrix whose column ranges are to be computed

Returns: Eigen::VectorXd Vector containing the range of each column

For each column j in matrix x, computes:

\[ range_j = \max_{i}(x_{ij}) - \min_{i}(x_{ij}) \]

where x_{ij} represents the i-th element of the j-th column.

Uses Eigen's efficient colwise() operations to compute maximum and minimum values for each column simultaneously.

Definition at line 728 of file math.h.

◆ ranges() [2/2]

template<typename T >

Eigen::VectorXd slope::ranges ( const Eigen::SparseMatrixBase< T > & x )

Computes the range (max - min) for each column of a matrix.

Parameters

x	Input matrix whose column ranges are to be computed

Returns: Eigen::VectorXd Vector containing the range of each column

For each column j in matrix x, computes:

\[ range_j = \max_{i}(x_{ij}) - \min_{i}(x_{ij}) \]

where x_{ij} represents the i-th element of the j-th column.

Definition at line 692 of file math.h.

◆ regularizationPath()

Eigen::ArrayXd slope::regularizationPath	(	const Eigen::ArrayXd &	alpha_in,
		const int	path_length,
		double	alpha_min_ratio,
		const double	alpha_max
	)

Computes a sequence of regularization weights for the SLOPE path.

Parameters

alpha_in	Alpha sequence, of length zero if automatic.
path_length	Length of path.
alpha_min_ratio	Ratio of minimum to maximum alpha
alpha_max	Value of alpha as which the model is completely sparse

Returns: Eigen::ArrayXd containing the sequence of regularization parameters from strongest (alpha_max) to weakest (alpha_max * alpha_min_ratio)

◆ rescaleCoefficients()

std::tuple< Eigen::VectorXd, Eigen::MatrixXd > slope::rescaleCoefficients	(	const Eigen::VectorXd &	beta0,
		const Eigen::SparseMatrix< double > &	beta,
		const Eigen::VectorXd &	x_centers,
		const Eigen::VectorXd &	x_scales,
		const bool	intercept
	)

Rescales the coefficients using the given parameters.

This function rescales the coefficients by dividing each coefficient by the corresponding scale factor and subtracting the product of the center and the coefficient from the intercept.

Parameters

beta0	The intercept coefficient.
beta	The vector of coefficients.
x_centers	The vector of center values.
x_scales	The vector of scale factors.
intercept	Should an intercept be fit?

Returns: A tuple containing the rescaled intercept and coefficients.

Note: The input vectors beta, x_centers, and x_scales must have the same size.; The output vector beta will be modified in-place.

See also: SlopeParameters

◆ rocAuc()

double slope::rocAuc	(	const Eigen::MatrixXd &	scores,
		const Eigen::MatrixXd &	labels
	)

Computes the Area Under the ROC Curve (AUC-ROC) for binary and multi-class classification.

Parameters

scores	Matrix of prediction scores/probabilities (samples x classes)
labels	Matrix of true labels in one-hot encoded format (samples x classes)

Returns: The average AUC-ROC score across all classes, between 0 and 1

For binary classification, this reduces to standard binary AUC-ROC. For multi-class, computes one-vs-rest AUC-ROC for each class and averages. Both input matrices must have the same dimensions.

◆ setDiff()

std::vector< int > slope::setDiff	(	const std::vector< int > &	a,
		const std::vector< int > &	b
	)

Computes the set difference of two sorted integer vectors.

Parameters

a	First sorted vector of integers (set to subtract from)
b	Second sorted vector of integers (set to subtract)

Returns: std::vector<int> Vector containing elements in a that do not appear in b, maintaining sorted order

Returns A \ B = {x ∈ A | x ∉ B}

◆ setUnion()

std::vector< int > slope::setUnion	(	const std::vector< int > &	a,
		const std::vector< int > &	b
	)

Computes the union of two sorted integer vectors.

Parameters

a	First sorted vector of integers
b	Second sorted vector of integers

Returns: std::vector<int> Vector containing all elements that appear in either a or b, without duplicates and in sorted order

◆ setupLoss()

std::unique_ptr< Loss > slope::setupLoss ( const std::string & loss )

Factory function to create the appropriate loss function based on the distribution family.

This function creates and returns an loss function object based on the specified statistical distribution family. The supported families are:

"logistic": For binary classification problems (logistic regression)
"poisson": For count data modeling (Poisson regression)
"multinomial": For multi-class classification problems
"quadratic": For continuous response variables (linear regression, default if unspecified)

Parameters

loss	A string specifying the loss type ("logistic", "poisson", "multinomial", or "quadratic")

Returns: std::unique_ptr<Loss> A unique pointer to the appropriate loss function object

◆ setupSolver()

std::unique_ptr< SolverBase > slope::setupSolver	(	const std::string &	solver_type,
		const std::string &	loss,
		JitNormalization	jit_normalization,
		bool	intercept,
		bool	update_clusters,
		int	cd_iterations,
		const std::string &	cd_type,
		std::optional< int >	random_seed = `std::nullopt`
	)

Factory function to create and configure a SLOPE solver.

Creates a solver object based on the specified type and parameters. The solver implements the Sorted L1 Penalized Estimation (SLOPE) algorithm with various configurations possible.

Parameters

solver_type	Type of solver to use (e.g., "pgd", "admm")
loss	Loss type
jit_normalization	Type of JIT normalization
intercept	Whether to fit an intercept term
update_clusters	Whether to update cluster assignments during optimization (Hybrid solver)
cd_iterations	Frequency of proximal gradient descent updates (Hybrid solver)
cd_type	Type of coordinate descent to use ("cyclical" or "permuted")
random_seed	Optional random seed for reproducibility

Returns: std::unique_ptr<SolverBase> A unique pointer to the configured solver

See also: Loss; JitNormalization; SolverBase; PGD; Hybrid

◆ sigmoid()

template<typename T >

T slope::sigmoid ( const T & x )

Calculates the sigmoid function for the given input.

The sigmoid function is defined as 1 / (1 + exp(-x)).

Template Parameters

T	The type of the input.

Parameters

x	The input value.

Returns: The result of the sigmoid function.

Definition at line 78 of file math.h.

◆ sign()

template<typename T >

int slope::sign ( T val )

Returns the sign of a given value.

This function determines the sign of the input value by comparing it to zero. It returns -1 if the value is negative, 0 if the value is zero, and 1 if the value is positive.

Template Parameters

T	The type of the input value.

Parameters

val	The value for which the sign needs to be determined.

Returns: -1 if the value is negative, 0 if the value is zero, and 1 if the value is positive.

Definition at line 37 of file math.h.

◆ slopeThreshold()

std::tuple< double, int > slope::slopeThreshold	(	const double	x,
		const int	j,
		const Eigen::ArrayXd &	lambda_cumsum,
		const Clusters &	clusters
	)

Calculates slope thresholding for a given input

This function calculates the slope threshold for a given x and j, using the provided lambdas and clusters. This is used in the coordinate descent update step.

Parameters

x	The value of x.
j	The value of j.
lambda_cumsum	Cumulative sum of the lambda sequence.
clusters	The clusters object.

Returns: A tuple containing the slope threshold and the index.

◆ softmax()

Eigen::MatrixXd slope::softmax ( const Eigen::MatrixXd & x )

Softmax

Computes the softmax function for the given input matrix.

Parameters

x A matrix

Returns: \(\exp(a) / \sum_i \exp(a_i)\)

◆ sort()

template<typename T >

void slope::sort	(	T &	v,
		const bool	descending = `false`
	)

Sorts the elements in a container in ascending or descending order.

This function sorts the elements in the container v in either ascending or descending order, depending on the value of the descending parameter.

Template Parameters

T	The type of the container.

Parameters

v	The container to be sorted.
descending	Flag indicating whether to sort in descending order (default is ascending order).

Note: The elements in the container must be comparable using the < and > operators.

See also: std::sort

Definition at line 69 of file utils.h.

◆ sortIndex()

template<typename T >

std::vector< int > slope::sortIndex	(	T &	v,
		const bool	descending = `false`
	)

Sorts the elements of a vector and returns the indices of the sorted elements.

This function sorts the elements of a vector in ascending or descending order and returns the indices of the sorted elements. The sorting is done using the std::sort function from the C++ standard library.

Template Parameters

T	The type of the vector elements.

Parameters

v	The vector to be sorted.
descending	Flag indicating whether to sort in descending order. Default is false.

Returns: A vector of indices representing the sorted order of the elements in the input vector.

Definition at line 123 of file utils.h.

◆ stdDevs() [1/2]

template<typename T >

Eigen::VectorXd slope::stdDevs ( const Eigen::MatrixBase< T > & x )

Computes the standard deviation for each column of a matrix.

Parameters

x	Input matrix whose column standard deviations are to be computed

Returns: Eigen::VectorXd Vector containing the standard deviation of each column

For each column j in matrix x, computes the standard deviation:

\[ \sigma_j = \sqrt{\frac{1}{n}\sum_{i} (x_{ij} - \bar{x}_j)^2} \]

where n is the number of rows, x_{ij} represents the i-th element of the j-th column, and \(\bar{x}_j\) is the mean of column j.

Definition at line 663 of file math.h.

◆ stdDevs() [2/2]

template<typename T >

Eigen::VectorXd slope::stdDevs ( const Eigen::SparseMatrixBase< T > & x )

Computes the standard deviation for each column of a matrix.

Parameters

x	Input matrix whose column standard deviations are to be computed

Returns: Eigen::VectorXd Vector containing the standard deviation of each column

For each column j in matrix x, computes the standard deviation:

\[ \sigma_j = \sqrt{\frac{1}{n}\sum_{i} (x_{ij} - \bar{x}_j)^2} \]

where n is the number of rows, x_{ij} represents the i-th element of the j-th column, and \(\bar{x}_j\) is the mean of column j.

Definition at line 618 of file math.h.

◆ strongSet()

std::vector< int > slope::strongSet	(	const Eigen::VectorXd &	gradient_prev,
		const Eigen::ArrayXd &	lambda,
		const Eigen::ArrayXd &	lambda_prev
	)

Determines the strong set using sequential strong rules.

Parameters

gradient_prev	Gradient from previous solution
lambda	Current lambda sequence
lambda_prev	Previous lambda sequence

Returns: std::vector<int> Indices of variables in the strong set

◆ subset() [1/3]

template<typename T >

Eigen::MatrixBase< T >::PlainObject slope::subset	(	const Eigen::DenseBase< T > &	x,
		const std::vector< int > &	indices
	)

Extract a subset of rows from an Eigen matrix.

Parameters

x	The input matrix to extract rows from
indices	A vector of row indices to extract

Returns: Eigen::MatrixXd A new matrix containing only the specified rows

This function creates a new matrix containing only the rows specified in the indices vector, preserving their order. The number of columns remains the same.

Definition at line 275 of file utils.h.

◆ subset() [2/3]

template<typename T >

T slope::subset	(	const Eigen::EigenBase< T > &	x,
		const std::vector< int > &	indices
	)

Extract a subset of rows from an Eigen matrix.

Parameters

x	The input matrix to extract rows from
indices	A vector of row indices to extract

Returns: Eigen::MatrixXd A new matrix containing only the specified rows

This function creates a new matrix containing only the rows specified in the indices vector, preserving their order. The number of columns remains the same.

Definition at line 257 of file utils.h.

◆ subset() [3/3]

template<typename T >

T slope::subset	(	const Eigen::SparseMatrixBase< T > &	x,
		const std::vector< int > &	indices
	)

Extract a subset of rows from a sparse Eigen matrix.

Parameters

x	The input sparse matrix to extract rows from
indices	A vector of row indices to extract

Returns: Eigen::SparseMatrix<double> A new sparse matrix containing only the specified rows

This function creates a new sparse matrix containing only the rows specified in the indices vector, preserving their order. The number of columns remains the same. The sparsity structure is maintained in the extracted rows.

Definition at line 295 of file utils.h.

◆ subsetCols() [1/2]

template<typename T >

T slope::subsetCols	(	const Eigen::MatrixBase< T > &	x,
		const std::vector< int > &	indices
	)

Extract specified columns from a dense matrix.

Creates a new matrix containing only the columns specified in the indices vector.

Template Parameters

MatrixType The type of matrix (supports both Eigen::MatrixXd and Eigen::Map<>)

Parameters

x	Input matrix
indices	Vector of column indices to extract (0-based)

Returns: Eigen::MatrixXd New matrix with only the selected columns

Definition at line 331 of file utils.h.

◆ subsetCols() [2/2]

template<typename T >

T slope::subsetCols	(	const Eigen::SparseMatrixBase< T > &	x,
		const std::vector< int > &	indices
	)

Extracts selected columns from a sparse matrix.

Creates a new sparse matrix containing only the columns specified by the indices vector. The resulting matrix preserves the sparsity structure and maintains the original row ordering.

Parameters

x	Input sparse matrix
indices	Vector of column indices to extract (0-based)

Returns: Sparse matrix containing only the selected columns

Definition at line 350 of file utils.h.

◆ unique()

std::unordered_set< double > slope::unique ( const Eigen::MatrixXd & x )

inline

Create a set of unique values from an Eigen matrix.

Parameters

x	The input matrix to extract unique values from

Returns: std::unordered_set<double> A set containing all unique values found in the matrix

This function iterates through all elements of the input matrix and collects all unique values into an unordered set. The order of elements in the returned set is not guaranteed.

Definition at line 380 of file utils.h.

◆ updateGradient()

template<typename T >

void slope::updateGradient	(	Eigen::VectorXd &	gradient,
		const T &	x,
		const Eigen::MatrixXd &	residual,
		const std::vector< int > &	active_set,
		const Eigen::VectorXd &	x_centers,
		const Eigen::VectorXd &	x_scales,
		const Eigen::VectorXd &	w,
		const JitNormalization	jit_normalization
	)

Computes the gradient of the loss with respect to \(\beta\).

Template Parameters

T	The type of the input matrix.

Parameters

gradient	The gradient vector.
x	The input matrix.
residual	The residual matrix.
active_set	The indices for the active set.
x_centers	The vector of center values for each column of x.
x_scales	The vector of scale values for each column of x.
w	Working weights
jit_normalization	Type of JIT normalization just-in-time.

Definition at line 234 of file math.h.

◆ validateOption()

void slope::validateOption	(	const std::string &	value,
		const std::set< std::string > &	valid_options,
		const std::string &	parameter_name
	)

Validates if a given value exists in a set of valid options.

Throws an informative error if the value is not found in the valid options, listing all valid possibilities in the error message.

Parameters

value	The value to validate
valid_options	Set of valid options
parameter_name	Name of the parameter being validated (used in error message).

Exceptions

std::invalid_argument If value is not in valid_options

◆ warningCodeToString()

std::string slope::warningCodeToString ( WarningCode code )

Convert a warning code to its string representation.

Parameters

code	The warning code to convert

Returns: std::string String representation of the warning code

◆ which()

template<typename T >

std::vector< int > slope::which ( const T & x )

Returns indices of true values in a boolean container.

Template Parameters

T	Container type supporting size() and operator[] (e.g., std::vector<bool>, std::array<bool>)

Parameters

x	Input container with boolean-convertible values

Returns: std::vector<int> containing indices where x[i] evaluates to true

Example: std::vector<bool> v = {true, false, true, false, true}; auto indices = which(v); // returns {0, 2, 4}

Definition at line 94 of file utils.h.

◆ whichBest()

template<typename T , typename Comparator >

int slope::whichBest	(	const T &	x,
		const Comparator &	comp
	)

Returns the index of the minimum element in a container.

Template Parameters

T	Container type that supports iterators and std::min_element

Parameters

x	Container whose maximum element's index is to be found
comp	Comparator that returns true if the first argument is worse than the second argument

Returns: int Zero-based index position of the maximum element

Uses std::max_element to find the iterator to the maximum element, then converts to index position using std::distance. For containers with multiple maximum elements, returns the first occurrence.

Definition at line 414 of file math.h.

◆ whichMax()

template<typename T >

int slope::whichMax ( const T & x )

Returns the index of the maximum element in a container.

Template Parameters

T	Container type that supports iterators and std::max_element

Parameters

x	Container whose maximum element's index is to be found

Returns: int Zero-based index position of the maximum element

Uses std::max_element to find the iterator to the maximum element, then converts to index position using std::distance. For containers with multiple maximum elements, returns the first occurrence.

Definition at line 376 of file math.h.

◆ whichMin()

template<typename T >

int slope::whichMin ( const T & x )

Returns the index of the minimum element in a container.

Template Parameters

T	Container type that supports iterators and std::min_element

Parameters

x	Container whose maximum element's index is to be found

Returns: int Zero-based index position of the maximum element

Uses std::max_element to find the iterator to the maximum element, then converts to index position using std::distance. For containers with multiple maximum elements, returns the first occurrence.

Definition at line 394 of file math.h.

Namespaces

Classes

Enumerations

Functions

Detailed Description

Enumeration Type Documentation

◆ JitNormalization

◆ WarningCode

Function Documentation

◆ activeSet()

◆ binaryRocAuc()

◆ clamp()

◆ clusterGradient()

◆ computeCenters()

◆ computeClusterGradientAndHessian() [1/2]

◆ computeClusterGradientAndHessian() [2/2]

◆ computeDual()

◆ computeGradientAndHessian()

◆ computeScales()

◆ coordinateDescent()

◆ createScreeningRule()

◆ crossValidate()

◆ cumSum()

◆ defaultInterruptChecker()

◆ estimateNoise()

◆ geomSpace()

◆ inversePermute()

◆ l1Norms()

◆ l2Norms() [1/2]

◆ l2Norms() [2/2]

◆ lambdaSequence()

◆ linearPredictor()

◆ logit()

◆ logSumExp()

◆ maxAbs() [1/2]

◆ maxAbs() [2/2]

◆ means() [1/2]

◆ means() [2/2]

◆ mins() [1/2]

◆ mins() [2/2]

◆ move_elements()

◆ nonZeros() [1/2]

◆ nonZeros() [2/2]

◆ normalize() [1/2]

◆ normalize() [2/2]

◆ offsetGradient()

◆ patternMatrix()

◆ permute()

◆ ranges() [1/2]

◆ ranges() [2/2]

◆ regularizationPath()

◆ rescaleCoefficients()

◆ rocAuc()

◆ setDiff()

◆ setUnion()

◆ setupLoss()

◆ setupSolver()

◆ sigmoid()

◆ sign()

◆ slopeThreshold()

◆ softmax()

◆ sort()

◆ sortIndex()

◆ stdDevs() [1/2]

◆ stdDevs() [2/2]

◆ strongSet()

◆ subset() [1/3]

◆ subset() [2/3]

◆ subset() [3/3]

◆ subsetCols() [1/2]

◆ subsetCols() [2/2]

◆ unique()

◆ updateGradient()

◆ validateOption()

◆ warningCodeToString()

◆ which()

◆ whichBest()

◆ whichMax()

◆ whichMin()