conquer/ 0000755 0001762 0000144 00000000000 14401323342 011722 5 ustar ligges users conquer/NAMESPACE 0000644 0001762 0000144 00000000711 14217232475 013153 0 ustar ligges users # Generated by roxygen2: do not edit by hand
export(conquer)
export(conquer.cv.reg)
export(conquer.process)
export(conquer.reg)
importFrom(Matrix,rankMatrix)
importFrom(Rcpp,evalCpp)
importFrom(matrixStats,colSds)
importFrom(matrixStats,rowMaxs)
importFrom(matrixStats,rowQuantiles)
importFrom(matrixStats,rowSds)
importFrom(stats,qnorm)
importFrom(stats,dnorm)
importFrom(stats,pnorm)
importFrom(stats,quantile)
importFrom(stats,runif)
useDynLib(conquer)
conquer/README.md 0000644 0001762 0000144 00000026523 14401306226 013213 0 ustar ligges users # conquer
**Con**volution-type smoothed **qu**antil**e** **r**egression
## Description
The `conquer` library performs fast and accurate convolution-type smoothed quantile regression ([Fernandes, Guerre and Horta, 2021](https://www.tandfonline.com/doi/full/10.1080/07350015.2019.1660177), [He et al., 2022](https://doi.org/10.1016/j.jeconom.2021.07.010), [Tan, Wang and Zhou, 2022](https://doi.org/10.1111/rssb.12485) for low/high-dimensional estimation and bootstrap inference.
In the low-dimensional setting, efficient gradient-based methods are employed for fitting both a single model and a regression process over a quantile range. Normal-based and (multiplier) bootstrap confidence intervals for all slope coefficients are constructed. In high dimensions, the conquer methods complemented with *ℓ1*-penalization and iteratively reweighted *ℓ1*-penalization are used to fit sparse models.
## Updates
**2023-03-05 (Version 1.3.3)**:
When calling `conquer` function with `ci = "asymptotic"`, an *n* by *n* diagonal matrix was involved for estimating asymptotic covariance matrix. This space allocation was expensive and unnecessary. In practice, on data with large *n*, computing the asymptotic confidence interval was infeasible.
This issue is mitigated via a more computationally efficient matrix multiplication. The space complexity is released from *O(n2)* to *O(np)*.
**2023-02-05 (Version 1.3.2)**:
1. Fix an issue in the `conquer.reg` function: when the penalties were group lasso, sparse group lasso or elastic-net, and the input *λ* was a sequence, the estimated coefficients were not reasonable. This didn't affect cross-validation (`conquer.cv.reg`), or `conquer.reg` with other penalties or when input *λ* was a scalar.
2. When the input *λ* of `conquer.reg` function was a sequence, the output estimation was a vector instead of a matrix, which was not consistent with the description of the function.
3. Update the default version of C++ as required by CRAN.
**2022-09-12 (Version 1.3.1)**:
Add flexibility into the `conquer` function:
1. The step size of Barzilai-Borweincan gradient descent can be unbounded, or the upper bound can be user-specified.
2. The smoothing bandwidth can be specified as any positive value. In previous versions, it has to be bounded away from zero.
**2022-03-24 (Version 1.3.0)**:
1. Add inference methods based on estimated asymptotic covariance matrix for low-dimensional conquer.
2. Add more flexible penalties (elastic-net, group Lasso and sparse group Lasso) into `conquer.reg` and `conquer.cv.reg` functions.
3. Speed up cross-validation using warm start along a sequence of *λ*'s.
**2022-02-12 (Version 1.2.2)**:
Remove the unnecessary dependent packge `caret` for a cleaner installation.
**2021-10-24 (Version 1.2.1)**:
Major updates:
1. Add a function `conquer.process` for conquer process over a quantile range.
2. Add functions `conquer.reg`, `conquer.cv.reg` for high-dimensional conquer with Lasso, SCAD and MCP penalties. The first function is called with a prescribed *λ*, and the second function calibrate *λ* via cross-validation. The candidates of *λ* can be user-specified, or automatically generated by simulating the pivotal quantity proposed in [Belloni and Chernozhukov, 2011](https://doi.org/10.1214/10-AOS827).
Minor updates:
1. Add logistic kernel for all the functions.
2. Modify initialization using asymmetric Huber regression.
3. Default number of tightening iterations is now 3.
4. Parameters for SCAD (default = 3.7) and MCP (default = 3) are added as arguments into the functions.
## Installation
`conquer` is available on [CRAN](https://CRAN.R-project.org/package=conquer), and it can be installed into `R` environment:
```r
install.packages("conquer")
```
## Common errors or warnings
**Compilation errors by `install.packages("conquer")` in R**:
It usually takes several days to build a binary package after we submit a source packge to CRAN. During that time period, only a source package for the new version is available. However, installing source packges (especially Rcpp-based ones) may cause various compilation errors. Hence, when users see the prompt "There is a binary version available but the source version is later. Do you want to install from sources the package which needs compilation?", we strongly recommend selecting **no**.
Below are a collection of error / warning messages and their solutions:
* Error: smqr.cpp: 'quantile' is not a member of 'arma’. **Solution**: 'quantile' function was added into `RcppArmadillo` version 0.9.850.1.0 (2020-02-09), so reinstalling / updating the library `RcppArmadillo` will fix this issue.
* Error: unable to load shared object.. Symbol not found: _EXTPTR_PTR. **Solution**: This issue is common in some specific versions of `R` when we load Rcpp-based libraries. It is an error in R caused by a minor change about `EXTPTR_PTR`. Upgrading R to 4.0.2 will solve the problem.
* Error: function 'Rcpp_precious_remove' not provided by package 'Rcpp'. **Solution**: This happens when a package is compiled against a recent `Rcpp` release, but users load it using an older version of `Rcpp`. Reinstalling the package `Rcpp` will solve the problem.
## Functions
There are 4 functions in this library:
* `conquer`: convolution-type smoothed quantile regression
* `conquer.process`: convolution-type smoothed quantile regression process
* `conquer.reg`: convolution-type smoothed quantile regression with regularization
* `conquer.cv.reg`: cross-validated convolution-type smoothed quantile regression with regularization
## Examples
### Quantile regression
Let us illustrate conquer by a simple example. For sample size *n = 5000* and dimension *p = 500*, we generate data from a linear model *yi = β0 + i, β> + εi*, for *i = 1, 2, ... n*. Here we set *β0 = 1*, *β* is a *p*-dimensional vector with every entry being *1*, *xi* follows *p*-dimensional standard multivariate normal distribution (available in the library `MASS`), and *εi* is from *t2* distribution.
```r
library(MASS)
library(quantreg)
library(conquer)
n = 5000
p = 500
beta = rep(1, p + 1)
set.seed(2021)
X = mvrnorm(n, rep(0, p), diag(p))
err = rt(n, 2)
Y = cbind(1, X) %*% beta + err
```
Then we run both quantile regression using package `quantreg`, with a Frisch-Newton approach after preprocessing ([Portnoy and Koenker, 1997](https://projecteuclid.org/euclid.ss/1030037960)), and conquer (with Gaussian kernel) on the generated data. The quantile level *τ* is fixed to be *0.5*.
```r
tau = 0.5
start = Sys.time()
fit.qr = rq(Y ~ X, tau = tau, method = "pfn")
end = Sys.time()
time.qr = as.numeric(difftime(end, start, units = "secs"))
est.qr = norm(as.numeric(fit.qr$coefficients) - beta, "2")
start = Sys.time()
fit.conquer = conquer(X, Y, tau = tau)
end = Sys.time()
time.conquer = as.numeric(difftime(end, start, units = "secs"))
est.conquer = norm(fit.conquer$coeff - beta, "2")
```
It takes 7.4 seconds to run the standard quantile regression but only 0.2 seconds to run conquer. In the meanwhile, the estimation error is 0.5186 for quantile regression and 0.4864 for conquer. For readers’ reference, these runtimes are recorded on a Macbook Pro with 2.3 GHz 8-Core Intel Core i9 processor, and 16 GB 2667 MHz DDR4 memory. We refer to [He et al., 2022](https://doi.org/10.1016/j.jeconom.2021.07.010) for a more extensive numerical study.
### Quantile regression process
We can also run conquer over a quantile range
```r
fit.conquer.process = conquer.process(X, Y, tauSeq = seq(0.2, 0.8, by = 0.05))
beta.conquer.process = fit.conquer.process$coeff
```
### Regularized quantile regression
Let us switch to the setting of high-dimensional sparse regression with *(n, p, s) = (200, 500, 5)*, and generate data accordingly.
```r
n = 200
p = 500
s = 5
beta = c(runif(s + 1, 1, 1.5), rep(0, p - s))
X = mvrnorm(n, rep(0, p), diag(p))
err = rt(n, 2)
Y = cbind(1, X) %*% beta + err
```
Regularized conquer can be executed with flexible penalitis, including Lasso, elastic-net, SCAD and MCP.
For all the penalties, the bandwidth parameter *h* is self-tuned, and the regularization parameter *λ* is selected via cross-validation.
```r
fit.lasso = conquer.cv.reg(X, Y, tau = 0.5, penalty = "lasso")
beta.lasso = fit.lasso$coeff
fit.elastic = conquer.cv.reg(X, Y, tau = 0.5, penalty = "elastic", para.elastic = 0.7)
beta.elastic = fit.elastic$coeff
fit.scad = conquer.cv.reg(X, Y, tau = 0.5, penalty = "scad")
beta.scad = fit.scad$coeff
fit.mcp = conquer.cv.reg(X, Y, tau = 0.5, penalty = "mcp")
beta.mcp = fit.mcp$coeff
```
Finally, group Lasso is also incorporated in to account for more complicated sparse structure.
The **group** argument stands for group indices, and it has to be specified for group Lasso.
```
n = 200
p = 500
s = 5
beta = c(1, rep(1.3, 2), rep(1.5, 3), rep(0, p - s))
X = matrix(rnorm(n * p), n, p)
err = rt(n, 2)
Y = cbind(1, X) %*% beta + err
group = c(rep(1, 2), rep(2, 3), rep(3, p - s))
fit.group = conquer.cv.reg(X, Y,tau = 0.5, penalty = "group", group = group)
beta.group = fit.group$coeff
```
## Getting help
Help on the functions can be accessed by typing `?`, followed by function name at the `R` command prompt.
For example, `?conquer` will present a detailed documentation with inputs, outputs and examples of the function `conquer`.
## License
GPL-3.0
## System requirements
C++17
## Authors
Xuming He , Xiaoou Pan , Kean Ming Tan and Wen-Xin Zhou
## Maintainer
Xiaoou Pan
## References
Barzilai, J. and Borwein, J. M. (1988). Two-point step size gradient methods. *IMA J. Numer. Anal.* **8** 141-148. [Paper](https://doi.org/10.1093/imanum/8.1.141)
Belloni, A. and Chernozhukov, V. (2011) *ℓ1*-penalized quantile regression in high-dimensional sparse models. *Ann. Statist.* **39** 82-130. [Paper](https://doi.org/10.1214/10-AOS827)
Fan, J., Liu, H., Sun, Q. and Zhang, T. (2018). I-LAMM for sparse learning: Simultaneous control of algorithmic complexity and statistical error. *Ann. Statist.* **46** 814-841. [Paper](https://projecteuclid.org/euclid.aos/1522742437)
Fernandes, M., Guerre, E. and Horta, E. (2021). Smoothing quantile regressions. *J. Bus. Econ. Statist.* **39** 338-357, [Paper](https://www.tandfonline.com/doi/full/10.1080/07350015.2019.1660177)
He, X., Pan, X., Tan, K. M., and Zhou, W.-X. (2023). Smoothed quantile regression with large-scale inference. *J. Econometrics*, **232**(2) 367-388, [Paper](https://doi.org/10.1016/j.jeconom.2021.07.010)
Koenker, R. (2005). Quantile Regression. Cambridge Univ. Press, Cambridge. [Book](https://www.cambridge.org/core/books/quantile-regression/C18AE7BCF3EC43C16937390D44A328B1)
Koenker, R. and Bassett, G. (1978). Regression quantiles. *Econometrica* **46** 33-50. [Paper](https://doi.org/10.2307/1913643)
Portnoy, S. and Koenker, R. (1997). The Gaussian hare and the Laplacian tortoise: Computability of squared-error versus absolute-error estimators. *Statist. Sci.* **12** 279–300. [Paper](https://projecteuclid.org/euclid.ss/1030037960)
Tan, K. M., Wang, L. and Zhou, W.-X. (2022). High-dimensional quantile regression: convolution smoothing and concave regularization. *J. Roy. Statist. Soc. Ser. B* **84(1)** 205-233. [Paper](https://doi.org/10.1111/rssb.12485)
conquer/man/ 0000755 0001762 0000144 00000000000 14401306545 012503 5 ustar ligges users conquer/man/conquer.reg.Rd 0000644 0001762 0000144 00000016647 14307551527 015247 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/smqr.R
\name{conquer.reg}
\alias{conquer.reg}
\title{Penalized Convolution-Type Smoothed Quantile Regression}
\usage{
conquer.reg(
X,
Y,
lambda = 0.2,
tau = 0.5,
kernel = c("Gaussian", "logistic", "uniform", "parabolic", "triangular"),
h = 0,
penalty = c("lasso", "elastic", "group", "sparse-group", "scad", "mcp"),
para.elastic = 0.5,
group = NULL,
weights = NULL,
para.scad = 3.7,
para.mcp = 3,
epsilon = 0.001,
iteMax = 500,
phi0 = 0.01,
gamma = 1.2,
iteTight = 3
)
}
\arguments{
\item{X}{An \eqn{n} by \eqn{p} design matrix. Each row is a vector of observations with \eqn{p} covariates.}
\item{Y}{An \eqn{n}-dimensional response vector.}
\item{lambda}{(\strong{optional}) Regularization parameter. Can be a scalar or a sequence. If the input is a sequence, the function will sort it in ascending order, and run the regression accordingly. Default is 0.2.}
\item{tau}{(\strong{optional}) Quantile level (between 0 and 1). Default is 0.5.}
\item{kernel}{(\strong{optional}) A character string specifying the choice of kernel function. Default is "Gaussian". Choices are "Gaussian", "logistic", "uniform", "parabolic" and "triangular".}
\item{h}{(\strong{optional}) Bandwidth/smoothing parameter. Default is \eqn{\max\{0.5 * (log(p) / n)^{0.25}, 0.05\}}. The default will be used if the input value is less than or equal to 0.}
\item{penalty}{(\strong{optional}) A character string specifying the penalty. Default is "lasso" (Tibshirani, 1996). The other options are "elastic" for elastic-net (Zou and Hastie, 2005), "group" for group lasso (Yuan and Lin, 2006), "sparse-group" for sparse group lasso (Simon et al., 2013), "scad" (Fan and Li, 2001) and "mcp" (Zhang, 2010).}
\item{para.elastic}{(\strong{optional}) The mixing parameter between 0 and 1 (usually noted as \eqn{\alpha}) for elastic-net. The penalty is defined as \eqn{\alpha ||\beta||_1 + (1 - \alpha) ||\beta||_2^2}. Default is 0.5.
Setting \code{para.elastic = 1} gives the lasso penalty, and setting \code{para.elastic = 0} yields the ridge penalty. Only specify it when \code{penalty = "elastic"}.}
\item{group}{(\strong{optional}) A \eqn{p}-dimensional vector specifying group indices. Only specify it if \code{penalty = "group"} or \code{penalty = "sparse-group"}.
For example, if \eqn{p = 10}, and we assume the first 3 coefficients belong to the first group, and the last 7 coefficients belong to the second group, then the argument should be \code{group = c(rep(1, 3), rep(2, 7))}. If not specified, then the penalty will be the classical lasso.}
\item{weights}{(\strong{optional}) A vector specifying groups weights for group Lasso and sparse group Lasso. The length must be equal to the number of groups. If not specified, the default weights are square roots of group sizes.
For example , if \code{group = c(rep(1, 3), rep(2, 7))}, then the default weights are \eqn{\sqrt{3}} for the first group, and \eqn{\sqrt{7}} for the second group.}
\item{para.scad}{(\strong{optional}) The constant parameter for "scad". Default value is 3.7. Only specify it if \code{penalty = "scad"}.}
\item{para.mcp}{(\strong{optional}) The constant parameter for "mcp". Default value is 3. Only specify it if \code{penalty = "mcp"}.}
\item{epsilon}{(\strong{optional}) A tolerance level for the stopping rule. The iteration will stop when the maximum magnitude of the change of coefficient updates is less than \code{epsilon}. Default is 0.001.}
\item{iteMax}{(\strong{optional}) Maximum number of iterations. Default is 500.}
\item{phi0}{(\strong{optional}) The initial quadratic coefficient parameter in the local adaptive majorize-minimize algorithm. Default is 0.01.}
\item{gamma}{(\strong{optional}) The adaptive search parameter (greater than 1) in the local adaptive majorize-minimize algorithm. Default is 1.2.}
\item{iteTight}{(\strong{optional}) Maximum number of tightening iterations in the iteratively reweighted \eqn{\ell_1}-penalized algorithm. Only specify it if the penalty is scad or mcp. Default is 3.}
}
\value{
An object containing the following items will be returned:
\describe{
\item{\code{coeff}}{If the input \code{lambda} is a scalar, then \code{coeff} returns a \eqn{(p + 1)} vector of estimated coefficients, including the intercept. If the input \code{lambda} is a sequence, then \code{coeff} returns a \eqn{(p + 1)} by \eqn{nlambda} matrix, where \eqn{nlambda} refers to the length of \code{lambda} sequence.}
\item{\code{bandwidth}}{Bandwidth value.}
\item{\code{tau}}{Quantile level.}
\item{\code{kernel}}{Kernel function.}
\item{\code{penalty}}{Penalty type.}
\item{\code{lambda}}{Regularization parameter(s).}
\item{\code{n}}{Sample size.}
\item{\code{p}}{Number of the covariates.}
}
}
\description{
Fit sparse quantile regression models in high dimensions via regularized conquer methods with "lasso", "elastic-net", "group lasso", "sparse group lasso", "scad" and "mcp" penalties.
For "scad" and "mcp", the iteratively reweighted \eqn{\ell_1}-penalized algorithm is complemented with a local adpative majorize-minimize algorithm.
}
\examples{
n = 200; p = 500; s = 10
beta = c(rep(1.5, s), rep(0, p - s))
X = matrix(rnorm(n * p), n, p)
Y = X \%*\% beta + rt(n, 2)
## Regularized conquer with lasso penalty at tau = 0.7
fit.lasso = conquer.reg(X, Y, lambda = 0.05, tau = 0.7, penalty = "lasso")
beta.lasso = fit.lasso$coeff
## Regularized conquer with elastic-net penalty at tau = 0.7
fit.elastic = conquer.reg(X, Y, lambda = 0.1, tau = 0.7, penalty = "elastic", para.elastic = 0.7)
beta.elastic = fit.elastic$coeff
## Regularized conquer with scad penalty at tau = 0.7
fit.scad = conquer.reg(X, Y, lambda = 0.13, tau = 0.7, penalty = "scad")
beta.scad = fit.scad$coeff
## Regularized conquer with group lasso at tau = 0.7
beta = c(rep(1.3, 5), rep(1.5, 5), rep(0, p - s))
err = rt(n, 2)
Y = X \%*\% beta + err
group = c(rep(1, 5), rep(2, 5), rep(3, p - s))
fit.group = conquer.reg(X, Y, lambda = 0.05, tau = 0.7, penalty = "group", group = group)
beta.group = fit.group$coeff
}
\references{
Belloni, A. and Chernozhukov, V. (2011). \eqn{\ell_1} penalized quantile regression in high-dimensional sparse models. Ann. Statist., 39, 82-130.
Fan, J. and Li, R. (2001). Variable selection via nonconcave regularized likelihood and its oracle properties. J. Amer. Statist. Assoc., 96, 1348-1360.
Fan, J., Liu, H., Sun, Q. and Zhang, T. (2018). I-LAMM for sparse learning: Simultaneous control of algorithmic complexity and statistical error. Ann. Statist., 46, 814-841.
Koenker, R. and Bassett, G. (1978). Regression quantiles. Econometrica, 46, 33-50.
Simon, N., Friedman, J., Hastie, T. and Tibshirani, R. (2013). A sparse-group lasso. J. Comp. Graph. Statist., 22, 231-245.
Tibshirani, R. (1996). Regression shrinkage and selection via the lasso. J. R. Statist. Soc. Ser. B, 58, 267–288.
Tan, K. M., Wang, L. and Zhou, W.-X. (2022). High-dimensional quantile regression: convolution smoothing and concave regularization. J. Roy. Statist. Soc. Ser. B, 84, 205-233.
Yuan, M. and Lin, Y. (2006). Model selection and estimation in regression with grouped variables., J. Roy. Statist. Soc. Ser. B, 68, 49-67.
Zhang, C.-H. (2010). Nearly unbiased variable selection under minimax concave penalty. Ann. Statist., 38, 894-942.
Zou, H. and Hastie, T. (2005). Regularization and variable selection via the elastic net. J. R. Statist. Soc. Ser. B, 67, 301-320.
}
\seealso{
See \code{\link{conquer.cv.reg}} for regularized quantile regression with cross-validation.
}
conquer/man/conquer.process.Rd 0000644 0001762 0000144 00000007145 14307554625 016143 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/smqr.R
\name{conquer.process}
\alias{conquer.process}
\title{Convolution-Type Smoothed Quantile Regression Process}
\usage{
conquer.process(
X,
Y,
tauSeq = seq(0.1, 0.9, by = 0.05),
kernel = c("Gaussian", "logistic", "uniform", "parabolic", "triangular"),
h = 0,
checkSing = FALSE,
tol = 1e-04,
iteMax = 5000,
stepBounded = TRUE,
stepMax = 100
)
}
\arguments{
\item{X}{An \eqn{n} by \eqn{p} design matrix. Each row is a vector of observations with \eqn{p} covariates. Number of observations \eqn{n} must be greater than number of covariates \eqn{p}.}
\item{Y}{An \eqn{n}-dimensional response vector.}
\item{tauSeq}{(\strong{optional}) A sequence of quantile values (between 0 and 1). Default is \eqn{\{0.1, 0.15, 0.2, ..., 0.85, 0.9\}}.}
\item{kernel}{(\strong{optional}) A character string specifying the choice of kernel function. Default is "Gaussian". Choices are "Gaussian", "logistic", "uniform", "parabolic" and "triangular".}
\item{h}{(\strong{optional}) The bandwidth/smoothing parameter. Default is \eqn{\max\{((log(n) + p) / n)^{0.4}, 0.05\}}. The default will be used if the input value is less than or equal to 0.}
\item{checkSing}{(\strong{optional}) A logical flag. Default is FALSE. If \code{checkSing = TRUE}, then it will check if the design matrix is singular before running conquer.}
\item{tol}{(\strong{optional}) Tolerance level of the gradient descent algorithm. The iteration will stop when the maximum magnitude of all the elements of the gradient is less than \code{tol}. Default is 1e-04.}
\item{iteMax}{(\strong{optional}) Maximum number of iterations. Default is 5000.}
\item{stepBounded}{(\strong{optional}) A logical flag. Default is TRUE. If \code{stepBounded = TRUE}, then the step size of gradient descent is upper bounded by \code{stepMax}. If \code{stepBounded = FALSE}, then the step size is unbounded.}
\item{stepMax}{(\strong{optional}) Maximum bound for the gradient descent step size. Default is 100.}
}
\value{
An object containing the following items will be returned:
\describe{
\item{\code{coeff}}{A \eqn{(p + 1)} by \eqn{m} matrix of estimated quantile regression process coefficients, including the intercept. m is the length of \code{tauSeq}.}
\item{\code{bandwidth}}{Bandwidth value.}
\item{\code{tauSeq}}{The sequence of quantile levels.}
\item{\code{kernel}}{The choice of kernel function.}
\item{\code{n}}{Sample size.}
\item{\code{p}}{Number the covariates.}
}
}
\description{
Fit a smoothed quantile regression process over a quantile range. The algorithm is essentially the same as \code{\link{conquer}}.
}
\examples{
n = 500; p = 10
beta = rep(1, p)
X = matrix(rnorm(n * p), n, p)
Y = X \%*\% beta + rt(n, 2)
## Smoothed quantile regression process with Gaussian kernel
fit.Gauss = conquer.process(X, Y, tauSeq = seq(0.2, 0.8, by = 0.05), kernel = "Gaussian")
beta.hat.Gauss = fit.Gauss$coeff
## Smoothe quantile regression with uniform kernel
fit.unif = conquer.process(X, Y, tauSeq = seq(0.2, 0.8, by = 0.05), kernel = "uniform")
beta.hat.unif = fit.unif$coeff
}
\references{
Barzilai, J. and Borwein, J. M. (1988). Two-point step size gradient methods. IMA J. Numer. Anal., 8, 141–148.
Fernandes, M., Guerre, E. and Horta, E. (2021). Smoothing quantile regressions. J. Bus. Econ. Statist., 39, 338-357.
He, X., Pan, X., Tan, K. M., and Zhou, W.-X. (2022+). Smoothed quantile regression for large-scale inference. J. Econometrics, in press.
Koenker, R. and Bassett, G. (1978). Regression quantiles. Econometrica, 46, 33-50.
}
\seealso{
See \code{\link{conquer}} for single-index smoothed quantile regression.
}
conquer/man/conquer-package.Rd 0000644 0001762 0000144 00000004135 14215204443 016037 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/conquer-package.R
\docType{package}
\name{conquer-package}
\alias{conquer-package}
\title{Conquer: Convolution-Type Smoothed Quantile Regression}
\description{
Estimation and inference for conditional linear quantile regression models using a convolution smoothed approach.
In the low-dimensional setting, efficient gradient-based methods are employed for fitting both a single model and a regression process over a quantile range. Normal-based and (multiplier) bootstrap confidence intervals for all slope coefficients are constructed.
In high dimensions, the conquer methods complemented with \eqn{\ell_1}-penalization and iteratively reweighted \eqn{\ell_1}-penalization are used to fit sparse models.
Commonly used penalities, such as the elastic-net, group lasso and sparse group lasso, are also incorporated to deal with more complex low-dimensional structures.
}
\references{
Barzilai, J. and Borwein, J. M. (1988). Two-point step size gradient methods. IMA J. Numer. Anal., 8, 141–148.
Belloni, A. and Chernozhukov, V. (2011). \eqn{\ell_1} penalized quantile regression in high-dimensional sparse models. Ann. Statist., 39, 82-130.
Fan, J., Liu, H., Sun, Q. and Zhang, T. (2018). I-LAMM for sparse learning: Simultaneous control of algorithmic complexity and statistical error. Ann. Statist., 46, 814-841.
Fernandes, M., Guerre, E. and Horta, E. (2021). Smoothing quantile regressions. J. Bus. Econ. Statist., 39, 338-357.
He, X., Pan, X., Tan, K. M., and Zhou, W.-X. (2022+). Smoothed quantile regression for large-scale inference. J. Econometrics, in press.
Koenker, R. (2005). Quantile Regression. Cambridge University Press, Cambridge.
Koenker, R. and Bassett, G. (1978). Regression quantiles. Econometrica, 46, 33-50.
Tan, K. M., Wang, L. and Zhou, W.-X. (2022). High-dimensional quantile regression: convolution smoothing and concave regularization. J. Roy. Statist. Soc. Ser. B, 84(1), 205-233.
}
\author{
Xuming He , Xiaoou Pan , Kean Ming Tan , and Wen-Xin Zhou
}
conquer/man/conquer.cv.reg.Rd 0000644 0001762 0000144 00000020550 14307551527 015642 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/smqr.R
\name{conquer.cv.reg}
\alias{conquer.cv.reg}
\title{Cross-Validated Penalized Convolution-Type Smoothed Quantile Regression}
\usage{
conquer.cv.reg(
X,
Y,
lambdaSeq = NULL,
tau = 0.5,
kernel = c("Gaussian", "logistic", "uniform", "parabolic", "triangular"),
h = 0,
penalty = c("lasso", "elastic", "group", "sparse-group", "scad", "mcp"),
para.elastic = 0.5,
group = NULL,
weights = NULL,
para.scad = 3.7,
para.mcp = 3,
kfolds = 5,
numLambda = 50,
epsilon = 0.001,
iteMax = 500,
phi0 = 0.01,
gamma = 1.2,
iteTight = 3
)
}
\arguments{
\item{X}{An \eqn{n} by \eqn{p} design matrix. Each row is a vector of observations with \eqn{p} covariates.}
\item{Y}{An \eqn{n}-dimensional response vector.}
\item{lambdaSeq}{(\strong{optional}) A sequence of candidate regularization parameters. If unspecified, the sequence will be generated by a simulated pivotal quantity approach proposed in Belloni and Chernozhukov (2011).}
\item{tau}{(\strong{optional}) Quantile level (between 0 and 1). Default is 0.5.}
\item{kernel}{(\strong{optional}) A character string specifying the choice of kernel function. Default is "Gaussian". Choices are "Gaussian", "logistic", "uniform", "parabolic" and "triangular".}
\item{h}{(\strong{optional}) The bandwidth parameter for kernel smoothing. Default is \eqn{\max\{0.5 * (log(p) / n)^{0.25}, 0.05\}}. The default will be used if the input value is less than or equal to 0.}
\item{penalty}{(\strong{optional}) A character string specifying the penalty. Default is "lasso" (Tibshirani, 1996). The other options are "elastic" for elastic-net (Zou and Hastie, 2005), "group" for group lasso (Yuan and Lin, 2006), "sparse-group" for sparse group lasso (Simon et al., 2013), "scad" (Fan and Li, 2001) and "mcp" (Zhang, 2010).}
\item{para.elastic}{(\strong{optional}) The mixing parameter between 0 and 1 (usually noted as \eqn{\alpha}) for elastic net. The penalty is defined as \eqn{\alpha ||\beta||_1 + (1 - \alpha) ||\beta||_2^2}. Default is 0.5.
Setting \code{para.elastic = 1} gives the lasso penalty, and setting \code{para.elastic = 0} yields the ridge penalty. Only specify it when \code{penalty = "elastic"}.}
\item{group}{(\strong{optional}) A \eqn{p}-dimensional vector specifying group indices. Only specify it if \code{penalty = "group"} or \code{penalty = "sparse-group"}.
For example, if \eqn{p = 10}, and we assume the first 3 coefficients belong to the first group, and the last 7 coefficients belong to the second group, then the argument should be \code{group = c(rep(1, 3), rep(2, 7))}. If not specified, then the penalty will be the classical lasso.}
\item{weights}{(\strong{optional}) A vector specifying groups weights for group Lasso and sparse group Lasso. The length must be equal to the number of groups. If not specified, the default weights are square roots of group sizes.
For example , if \code{group = c(rep(1, 3), rep(2, 7))}, then the default weights are \eqn{\sqrt{3}} for the first group, and \eqn{\sqrt{7}} for the second group.}
\item{para.scad}{(\strong{optional}) The constant parameter for "scad". Default value is 3.7. Only specify it if \code{penalty = "scad"}.}
\item{para.mcp}{(\strong{optional}) The constant parameter for "mcp". Default value is 3. Only specify it if \code{penalty = "mcp"}.}
\item{kfolds}{(\strong{optional}) Number of folds for cross-validation. Default is 5.}
\item{numLambda}{(\strong{optional}) Number of \eqn{\lambda} values for cross-validation if \code{lambdaSeq} is unspeficied. Default is 50.}
\item{epsilon}{(\strong{optional}) A tolerance level for the stopping rule. The iteration will stop when the maximum magnitude of the change of coefficient updates is less than \code{epsilon}. Default is 0.001.}
\item{iteMax}{(\strong{optional}) Maximum number of iterations. Default is 500.}
\item{phi0}{(\strong{optional}) The initial quadratic coefficient parameter in the local adaptive majorize-minimize algorithm. Default is 0.01.}
\item{gamma}{(\strong{optional}) The adaptive search parameter (greater than 1) in the local adaptive majorize-minimize algorithm. Default is 1.2.}
\item{iteTight}{(\strong{optional}) Maximum number of tightening iterations in the iteratively reweighted \eqn{\ell_1}-penalized algorithm. Only specify it if the penalty is scad or mcp. Default is 3.}
}
\value{
An object containing the following items will be returned:
\describe{
\item{\code{coeff.min}}{A \eqn{(p + 1)} vector of estimated coefficients including the intercept selected by minimizing the cross-validation errors.}
\item{\code{coeff.1se}}{A \eqn{(p + 1)} vector of estimated coefficients including the intercept. The corresponding \eqn{\lambda} is the largest \eqn{\lambda} such that the cross-validation error is within 1 standard error of the minimum.}
\item{\code{lambdaSeq}}{The sequence of regularization parameter candidates for cross-validation.}
\item{\code{lambda.min}}{Regularization parameter selected by minimizing the cross-validation errors. This is the corresponding \eqn{\lambda} of \code{coeff.min}.}
\item{\code{lambda.1se}}{The largest regularization parameter such that the cross-validation error is within 1 standard error of the minimum. This is the corresponding \eqn{\lambda} of \code{coeff.1se}.}
\item{\code{deviance}}{Cross-validation errors based on the quantile loss. The length is equal to the length of \code{lambdaSeq}.}
\item{\code{deviance.se}}{Estimated standard errors of \code{deviance}. The length is equal to the length of \code{lambdaSeq}.}
\item{\code{bandwidth}}{Bandwidth value.}
\item{\code{tau}}{Quantile level.}
\item{\code{kernel}}{Kernel function.}
\item{\code{penalty}}{Penalty type.}
\item{\code{n}}{Sample size.}
\item{\code{p}}{Number of covariates.}
}
}
\description{
Fit sparse quantile regression models via regularized conquer methods with "lasso", "elastic-net", "group lasso", "sparse group lasso", "scad" and "mcp" penalties. The regularization parameter \eqn{\lambda} is selected via cross-validation.
}
\examples{
n = 100; p = 200; s = 5
beta = c(rep(1.5, s), rep(0, p - s))
X = matrix(rnorm(n * p), n, p)
Y = X \%*\% beta + rt(n, 2)
## Cross-validated regularized conquer with lasso penalty at tau = 0.7
fit.lasso = conquer.cv.reg(X, Y, tau = 0.7, penalty = "lasso")
beta.lasso = fit.lasso$coeff.min
## Cross-validated regularized conquer with elastic-net penalty at tau = 0.7
fit.elastic = conquer.cv.reg(X, Y, tau = 0.7, penalty = "elastic", para.elastic = 0.7)
beta.elastic = fit.elastic$coeff.min
## Cross-validated regularized conquer with scad penalty at tau = 0.7
fit.scad = conquer.cv.reg(X, Y, tau = 0.7, penalty = "scad")
beta.scad = fit.scad$coeff.min
## Regularized conquer with group lasso at tau = 0.7
beta = c(rep(1.3, 2), rep(1.5, 3), rep(0, p - s))
err = rt(n, 2)
Y = X \%*\% beta + err
group = c(rep(1, 2), rep(2, 3), rep(3, p - s))
fit.group = conquer.cv.reg(X, Y,tau = 0.7, penalty = "group", group = group)
beta.group = fit.group$coeff.min
}
\references{
Belloni, A. and Chernozhukov, V. (2011). \eqn{\ell_1} penalized quantile regression in high-dimensional sparse models. Ann. Statist., 39, 82-130.
Fan, J. and Li, R. (2001). Variable selection via nonconcave regularized likelihood and its oracle properties. J. Amer. Statist. Assoc., 96, 1348-1360.
Fan, J., Liu, H., Sun, Q. and Zhang, T. (2018). I-LAMM for sparse learning: Simultaneous control of algorithmic complexity and statistical error. Ann. Statist., 46, 814-841.
Koenker, R. and Bassett, G. (1978). Regression quantiles. Econometrica, 46, 33-50.
Simon, N., Friedman, J., Hastie, T. and Tibshirani, R. (2013). A sparse-group lasso. J. Comp. Graph. Statist., 22, 231-245.
Tibshirani, R. (1996). Regression shrinkage and selection via the lasso. J. R. Statist. Soc. Ser. B, 58, 267–288.
Tan, K. M., Wang, L. and Zhou, W.-X. (2022). High-dimensional quantile regression: convolution smoothing and concave regularization. J. Roy. Statist. Soc. Ser. B, 84, 205-233.
Yuan, M. and Lin, Y. (2006). Model selection and estimation in regression with grouped variables., J. Roy. Statist. Soc. Ser. B, 68, 49-67.
Zhang, C.-H. (2010). Nearly unbiased variable selection under minimax concave penalty. Ann. Statist., 38, 894-942.
Zou, H. and Hastie, T. (2005). Regularization and variable selection via the elastic net. J. R. Statist. Soc. Ser. B, 67, 301-320.
}
\seealso{
See \code{\link{conquer.reg}} for regularized quantile regression with a prescribed \eqn{lambda}.
}
conquer/man/conquer.Rd 0000644 0001762 0000144 00000012547 14307776410 014466 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/smqr.R
\name{conquer}
\alias{conquer}
\title{Convolution-Type Smoothed Quantile Regression}
\usage{
conquer(
X,
Y,
tau = 0.5,
kernel = c("Gaussian", "logistic", "uniform", "parabolic", "triangular"),
h = 0,
checkSing = FALSE,
tol = 1e-04,
iteMax = 5000,
stepBounded = TRUE,
stepMax = 100,
ci = c("none", "bootstrap", "asymptotic", "both"),
alpha = 0.05,
B = 1000
)
}
\arguments{
\item{X}{An \eqn{n} by \eqn{p} design matrix. Each row is a vector of observations with \eqn{p} covariates. Number of observations \eqn{n} must be greater than number of covariates \eqn{p}.}
\item{Y}{An \eqn{n}-dimensional response vector.}
\item{tau}{(\strong{optional}) The desired quantile level. Default is 0.5. Value must be between 0 and 1.}
\item{kernel}{(\strong{optional}) A character string specifying the choice of kernel function. Default is "Gaussian". Choices are "Gaussian", "logistic", "uniform", "parabolic" and "triangular".}
\item{h}{(\strong{optional}) Bandwidth/smoothing parameter. Default is \eqn{\max\{((log(n) + p) / n)^{0.4}, 0.05\}}. The default will be used if the input value is less than or equal to 0.}
\item{checkSing}{(\strong{optional}) A logical flag. Default is FALSE. If \code{checkSing = TRUE}, then it will check if the design matrix is singular before running conquer.}
\item{tol}{(\strong{optional}) Tolerance level of the gradient descent algorithm. The iteration will stop when the maximum magnitude of all the elements of the gradient is less than \code{tol}. Default is 1e-04.}
\item{iteMax}{(\strong{optional}) Maximum number of iterations. Default is 5000.}
\item{stepBounded}{(\strong{optional}) A logical flag. Default is TRUE. If \code{stepBounded = TRUE}, then the step size of gradient descent is upper bounded by \code{stepMax}. If \code{stepBounded = FALSE}, then the step size is unbounded.}
\item{stepMax}{(\strong{optional}) Maximum bound for the gradient descent step size. Default is 100.}
\item{ci}{(\strong{optional}) A character string specifying methods to construct confidence intervals. Choices are "none" (default), "bootstrap", "asymptotic" and "both". If \code{ci = "none"}, then confidence intervals will not be constructed.
If \code{ci = "bootstrap"}, then three types of confidence intervals (percentile, pivotal and normal) will be constructed via multiplier bootstrap.
If \code{ci = "asymptotic"}, then confidence intervals will be constructed based on estimated asymptotic covariance matrix.
If \code{ci = "both"}, then confidence intervals from both bootstrap and asymptotic covariance will be returned.}
\item{alpha}{(\strong{optional}) Miscoverage level for each confidence interval. Default is 0.05.}
\item{B}{(\strong{optional}) The size of bootstrap samples. Default is 1000.}
}
\value{
An object containing the following items will be returned:
\describe{
\item{\code{coeff}}{A \eqn{(p + 1)}-vector of estimated quantile regression coefficients, including the intercept.}
\item{\code{ite}}{Number of iterations until convergence.}
\item{\code{residual}}{An \eqn{n}-vector of fitted residuals.}
\item{\code{bandwidth}}{Bandwidth value.}
\item{\code{tau}}{Quantile level.}
\item{\code{kernel}}{Kernel function.}
\item{\code{n}}{Sample size.}
\item{\code{p}}{Number of covariates.}
\item{\code{perCI}}{The percentile confidence intervals for regression coefficients. Only available if \code{ci = "bootstrap"} or \code{ci = "both"}.}
\item{\code{pivCI}}{The pivotal confidence intervals for regression coefficients. Only available if \code{ci = "bootstrap"} or \code{ci = "both"}.}
\item{\code{normCI}}{The normal-based confidence intervals for regression coefficients. Only available if \code{ci = "bootstrap"} or \code{ci = "both"}.}
\item{\code{asyCI}}{The asymptotic confidence intervals for regression coefficients. Only available if \code{ci = "asymptotic"} or \code{ci = "both"}.}
}
}
\description{
Estimation and inference for conditional linear quantile regression models using a convolution smoothed approach. Efficient gradient-based methods are employed for fitting both a single model and a regression process over a quantile range.
Normal-based and (multiplier) bootstrap confidence intervals for all slope coefficients are constructed.
}
\examples{
n = 500; p = 10
beta = rep(1, p)
X = matrix(rnorm(n * p), n, p)
Y = X \%*\% beta + rt(n, 2)
## Smoothed quantile regression with Gaussian kernel
fit.Gauss = conquer(X, Y, tau = 0.5, kernel = "Gaussian")
beta.hat.Gauss = fit.Gauss$coeff
## Smoothe quantile regression with uniform kernel
fit.unif = conquer(X, Y, tau = 0.5, kernel = "uniform")
beta.hat.unif = fit.unif$coeff
## Construct three types of confidence intervals via multiplier bootstrap
fit = conquer(X, Y, tau = 0.5, kernel = "Gaussian", ci = "bootstrap")
ci.per = fit$perCI
ci.piv = fit$pivCI
ci.norm = fit$normCI
}
\references{
Barzilai, J. and Borwein, J. M. (1988). Two-point step size gradient methods. IMA J. Numer. Anal., 8, 141–148.
Fernandes, M., Guerre, E. and Horta, E. (2021). Smoothing quantile regressions. J. Bus. Econ. Statist., 39, 338-357.
He, X., Pan, X., Tan, K. M., and Zhou, W.-X. (2022+). Smoothed quantile regression for large-scale inference. J. Econometrics, in press.
Koenker, R. and Bassett, G. (1978). Regression quantiles. Econometrica, 46, 33-50.
}
\seealso{
See \code{\link{conquer.process}} for smoothed quantile regression process.
}
conquer/DESCRIPTION 0000644 0001762 0000144 00000003006 14401323342 013427 0 ustar ligges users Package: conquer
Type: Package
Title: Convolution-Type Smoothed Quantile Regression
Version: 1.3.3
Date: 2023-03-05
Authors@R: c(person("Xuming", "He", email = "xmhe@umich.edu", role = "aut"),
person("Xiaoou", "Pan", email = "xip024@ucsd.edu", role = c("aut", "cre")),
person("Kean Ming", "Tan", email = "keanming@umich.edu", role = "aut"),
person("Wen-Xin", "Zhou", email = "wez243@ucsd.edu", role = "aut"))
Description: Estimation and inference for conditional linear quantile regression models using a convolution smoothed approach. In the low-dimensional setting, efficient gradient-based methods are employed for fitting both a single model and a regression process over a quantile range. Normal-based and (multiplier) bootstrap confidence intervals for all slope coefficients are constructed. In high dimensions, the conquer method is complemented with flexible types of penalties (Lasso, elastic-net, group lasso, sparse group lasso, scad and mcp) to deal with complex low-dimensional structures.
Depends: R (>= 3.5.0)
License: GPL-3
Encoding: UTF-8
URL: https://github.com/XiaoouPan/conquer
SystemRequirements: C++17
Imports: Rcpp (>= 1.0.3), Matrix, matrixStats, stats
LinkingTo: Rcpp, RcppArmadillo (>= 0.9.850.1.0)
RoxygenNote: 7.2.1
NeedsCompilation: yes
Packaged: 2023-03-06 06:51:17 UTC; xopan
Author: Xuming He [aut],
Xiaoou Pan [aut, cre],
Kean Ming Tan [aut],
Wen-Xin Zhou [aut]
Maintainer: Xiaoou Pan
Repository: CRAN
Date/Publication: 2023-03-06 08:40:02 UTC
conquer/src/ 0000755 0001762 0000144 00000000000 14401306545 012517 5 ustar ligges users conquer/src/highdTrian.cpp 0000644 0001762 0000144 00000132124 14367651664 015327 0 ustar ligges users # include
# include
# include "basicOp.h"
// [[Rcpp::depends(RcppArmadillo)]]
// [[Rcpp::plugins(cpp11)]]
// [[Rcpp::export]]
double lossTrianHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const double h, const double h1, const double h2) {
arma::vec res = Y - Z * beta;
arma::vec temp = (tau - 0.5) * res;
for (int i = 0; i < res.size(); i++) {
double cur = std::abs(res(i));
temp(i) += cur <= h ? (0.5 * h1 * cur * cur - 0.1666667 * h2 * cur * cur * cur + 0.1666667 * h) : 0.5 * cur;
}
return arma::mean(temp);
}
// [[Rcpp::export]]
double updateTrianHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double tau, const double n1, const double h,
const double h1, const double h2) {
arma::vec res = Y - Z * beta;
arma::vec temp = (tau - 0.5) * res;
arma::vec der(res.size());
for (int i = 0; i < res.size(); i++) {
double cur = res(i);
if (cur <= -h) {
der(i) = 1 - tau;
temp(i) -= 0.5 * cur;
} else if (cur < 0) {
der(i) = 0.5 - tau - h1 * cur - 0.5 * h2 * cur * cur;
temp(i) += 0.5 * h1 * cur * cur + 0.1666667 * h2 * cur * cur * cur + 0.1666667 * h;
} else if (cur < h) {
der(i) = 0.5 - tau - h1 * cur + 0.5 * h2 * cur * cur;
temp(i) += 0.5 * h1 * cur * cur - 0.1666667 * h2 * cur * cur * cur + 0.1666667 * h;
} else {
der(i) = -tau;
temp(i) += 0.5 * cur;
}
}
grad = n1 * Z.t() * der;
return arma::mean(temp);
}
// [[Rcpp::export]]
double lammTrianLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi,
const double gamma, const int p, const double h, const double n1, const double h1, const double h2) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateTrianHd(Z, Y, beta, grad, tau, n1, h, h1, h2);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = Lambda / phiNew;
betaNew = softThresh(first, second, p);
double fVal = lossTrianHd(Z, Y, betaNew, tau, h, h1, h2);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammTrianElastic(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double alpha,
const double phi, const double gamma, const int p, const double h, const double n1, const double h1, const double h2) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateTrianHd(Z, Y, beta, grad, tau, n1, h, h1, h2);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = alpha * Lambda / phiNew;
betaNew = softThresh(first, second, p) / (1.0 + (2.0 - 2 * alpha) * Lambda / phiNew);
double fVal = lossTrianHd(Z, Y, betaNew, tau, h, h1, h2);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammTrianGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, arma::vec& beta, const double tau, const arma::vec& group,
const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1,
const double h1, const double h2) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateTrianHd(Z, Y, beta, grad, tau, n1, h, h1, h2);
while (true) {
arma::vec subNorm = arma::zeros(G);
betaNew = beta - grad / phiNew;
for (int i = 1; i <= p; i++) {
subNorm(group(i)) += betaNew(i) * betaNew(i);
}
subNorm = arma::max(1.0 - lambda * weight / (phiNew * arma::sqrt(subNorm)), arma::zeros(G));
for (int i = 1; i <= p; i++) {
betaNew(i) *= subNorm(group(i));
}
double fVal = lossTrianHd(Z, Y, betaNew, tau, h, h1, h2);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammTrianSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, const double lambda, arma::vec& beta, const double tau,
const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G,
const double h, const double n1, const double h1, const double h2) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateTrianHd(Z, Y, beta, grad, tau, n1, h, h1, h2);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = Lambda / phiNew;
betaNew = softThresh(first, second, p);
arma::vec subNorm = arma::zeros(G);
for (int i = 1; i <= p; i++) {
subNorm(group(i)) += betaNew(i) * betaNew(i);
}
subNorm = arma::max(1.0 - lambda * weight / (phiNew * arma::sqrt(subNorm)), arma::zeros(G));
for (int i = 1; i <= p; i++) {
betaNew(i) *= subNorm(group(i));
}
double fVal = lossTrianHd(Z, Y, betaNew, tau, h, h1, h2);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
arma::vec trianLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec trianLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec trianElastic(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const double alpha, const int p, const double n1,
const double h, const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianElastic(Z, Y, Lambda, betaNew, tau, alpha, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec trianElasticWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const double alpha,
const int p, const double n1, const double h, const double h1, const double h2, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianElastic(Z, Y, Lambda, betaNew, tau, alpha, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec trianGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianGroupLasso(Z, Y, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec trianGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau,
const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h,
const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianGroupLasso(Z, Y, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec trianSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianSparseGroupLasso(Z, Y, Lambda, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec trianSparseGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianSparseGroupLasso(Z, Y, Lambda, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec trianScad(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500, const int iteTight = 3, const double para = 3.7) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaSCAD(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
int iteT = 1;
// Tightening
arma::vec beta0(p + 1);
while (iteT <= iteTight) {
iteT++;
beta = betaNew;
beta0 = betaNew;
Lambda = cmptLambdaSCAD(beta, lambda, p, para);
phi = phi0;
ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
if (arma::norm(betaNew - beta0, "inf") <= epsilon) {
break;
}
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec trianScadWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500, const double para = 3.7) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaSCAD(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec trianMcp(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500, const int iteTight = 3, const double para = 3) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaMCP(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
int iteT = 1;
// Tightening
arma::vec beta0(p + 1);
while (iteT <= iteTight) {
iteT++;
beta = betaNew;
beta0 = betaNew;
Lambda = cmptLambdaMCP(beta, lambda, p, para);
phi = phi0;
ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
if (arma::norm(betaNew - beta0, "inf") <= epsilon) {
break;
}
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec trianMcpWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500, const double para = 3) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaMCP(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammTrianLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec conquerTrianLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = trianLasso(Z, Y, lambda, tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerTrianLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = trianLasso(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = trianLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerTrianElastic(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double alpha, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = trianElastic(Z, Y, lambda, tau, alpha, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerTrianElasticSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double alpha, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = trianElastic(Z, Y, lambdaSeq(0), tau, alpha, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = trianElasticWarm(Z, Y, lambdaSeq(i), betaWarm, tau, alpha, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerTrianGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = trianGroupLasso(Z, Y, lambda, tau, group, weight, p, G, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerTrianGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = trianGroupLasso(Z, Y, lambdaSeq(0), tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = trianGroupLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerTrianSparseGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = trianSparseGroupLasso(Z, Y, lambda, tau, group, weight, p, G, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerTrianSparseGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight,
const int G, const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = trianSparseGroupLasso(Z, Y, lambdaSeq(0), tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = trianSparseGroupLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerTrianScad(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500, const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = trianScad(Z, Y, lambda, tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerTrianScadSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = trianScad(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = trianScadWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, para);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerTrianMcp(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500, const int iteTight = 3, const double para = 3.0) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = trianMcp(Z, Y, lambda, tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerTrianMcpSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.0) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = trianMcp(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = trianMcpWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, para);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
Rcpp::List cvTrianLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = trianLasso(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = trianLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = trianLasso(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = trianLasso(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvTrianElasticWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const double alpha,
const int kfolds, const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = trianElastic(trainZ, trainY, lambdaSeq(0), tau, alpha, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = trianElasticWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, alpha, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = trianElastic(Z, Y, lambdaSeq(cvIdx), tau, alpha, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = trianElastic(Z, Y, lambdaSeq(seIdx), tau, alpha, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvTrianGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = trianGroupLasso(trainZ, trainY, lambdaSeq(0), tau, group, weight, p, G, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = trianGroupLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = trianGroupLasso(Z, Y, lambdaSeq(cvIdx), tau, group, weight, p, G, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = trianGroupLasso(Z, Y, lambdaSeq(seIdx), tau, group, weight, p, G, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvTrianSparseGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau,
const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = trianSparseGroupLasso(trainZ, trainY, lambdaSeq(0), tau, group, weight, p, G, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = trianSparseGroupLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = trianSparseGroupLasso(Z, Y, lambdaSeq(cvIdx), tau, group, weight, p, G, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = trianSparseGroupLasso(Z, Y, lambdaSeq(seIdx), tau, group, weight, p, G, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvTrianScadWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = trianScad(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = trianScadWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax, para);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = trianScad(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = trianScad(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvTrianMcpWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.5, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = trianMcp(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = trianMcpWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax, para);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = trianMcp(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = trianMcp(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
conquer/src/highdPara.cpp 0000644 0001762 0000144 00000131517 14367651474 015141 0 ustar ligges users # include
# include
# include "basicOp.h"
// [[Rcpp::depends(RcppArmadillo)]]
// [[Rcpp::plugins(cpp11)]]
// [[Rcpp::export]]
double lossParaHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const double h, const double h1, const double h3) {
arma::vec res = Y - Z * beta;
arma::vec temp = (tau - 0.5) * res;
for (int i = 0; i < res.size(); i++) {
double cur = std::abs(res(i));
temp(i) += cur <= h ? (0.375 * h1 * cur * cur - 0.0625 * h3 * cur * cur * cur * cur + 0.1875 * h) : 0.5 * cur;
}
return arma::mean(temp);
}
// [[Rcpp::export]]
double updateParaHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double tau, const double n1, const double h,
const double h1, const double h3) {
arma::vec res = Y - Z * beta;
arma::vec temp = (tau - 0.5) * res;
arma::vec der(res.size());
for (int i = 0; i < res.size(); i++) {
double cur = res(i);
if (cur <= -h) {
der(i) = 1 - tau;
temp(i) -= 0.5 * cur;
} else if (cur < h) {
der(i) = 0.5 - tau - 0.75 * h1 * cur + 0.25 * h3 * cur * cur * cur;
temp(i) += 0.375 * h1 * cur * cur - 0.0625 * h3 * cur * cur * cur * cur + 0.1875 * h;
} else {
der(i) = -tau;
temp(i) += 0.5 * cur;
}
}
grad = n1 * Z.t() * der;
return arma::mean(temp);
}
// [[Rcpp::export]]
double lammParaLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi,
const double gamma, const int p, const double h, const double n1, const double h1, const double h3) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateParaHd(Z, Y, beta, grad, tau, n1, h, h1, h3);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = Lambda / phiNew;
betaNew = softThresh(first, second, p);
double fVal = lossParaHd(Z, Y, betaNew, tau, h, h1, h3);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammParaElastic(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double alpha,
const double phi, const double gamma, const int p, const double h, const double n1, const double h1, const double h3) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateParaHd(Z, Y, beta, grad, tau, n1, h, h1, h3);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = alpha * Lambda / phiNew;
betaNew = softThresh(first, second, p) / (1.0 + (2.0 - 2 * alpha) * Lambda / phiNew);
double fVal = lossParaHd(Z, Y, betaNew, tau, h, h1, h3);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammParaGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, arma::vec& beta, const double tau, const arma::vec& group,
const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1,
const double h1, const double h3) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateParaHd(Z, Y, beta, grad, tau, n1, h, h1, h3);
while (true) {
arma::vec subNorm = arma::zeros(G);
betaNew = beta - grad / phiNew;
for (int i = 1; i <= p; i++) {
subNorm(group(i)) += betaNew(i) * betaNew(i);
}
subNorm = arma::max(1.0 - lambda * weight / (phiNew * arma::sqrt(subNorm)), arma::zeros(G));
for (int i = 1; i <= p; i++) {
betaNew(i) *= subNorm(group(i));
}
double fVal = lossParaHd(Z, Y, betaNew, tau, h, h1, h3);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammParaSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, const double lambda, arma::vec& beta, const double tau,
const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G,
const double h, const double n1, const double h1, const double h3) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateParaHd(Z, Y, beta, grad, tau, n1, h, h1, h3);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = Lambda / phiNew;
betaNew = softThresh(first, second, p);
arma::vec subNorm = arma::zeros(G);
for (int i = 1; i <= p; i++) {
subNorm(group(i)) += betaNew(i) * betaNew(i);
}
subNorm = arma::max(1.0 - lambda * weight / (phiNew * arma::sqrt(subNorm)), arma::zeros(G));
for (int i = 1; i <= p; i++) {
betaNew(i) *= subNorm(group(i));
}
double fVal = lossParaHd(Z, Y, betaNew, tau, h, h1, h3);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
arma::vec paraLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double h3, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec paraLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double h3, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec paraElastic(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const double alpha, const int p, const double n1,
const double h, const double h1, const double h3, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaElastic(Z, Y, Lambda, betaNew, tau, alpha, phi, gamma, p, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec paraElasticWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const double alpha,
const int p, const double n1, const double h, const double h1, const double h3, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaElastic(Z, Y, Lambda, betaNew, tau, alpha, phi, gamma, p, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec paraGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h3,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaGroupLasso(Z, Y, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec paraGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau,
const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h,
const double h1, const double h3, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaGroupLasso(Z, Y, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec paraSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h3,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaSparseGroupLasso(Z, Y, Lambda, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec paraSparseGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h3,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaSparseGroupLasso(Z, Y, Lambda, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec paraScad(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double h3, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500, const int iteTight = 3, const double para = 3.7) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaSCAD(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
int iteT = 1;
// Tightening
arma::vec beta0(p + 1);
while (iteT <= iteTight) {
iteT++;
beta = betaNew;
beta0 = betaNew;
Lambda = cmptLambdaSCAD(beta, lambda, p, para);
phi = phi0;
ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
if (arma::norm(betaNew - beta0, "inf") <= epsilon) {
break;
}
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec paraScadWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double h3, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500, const double para = 3.7) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaSCAD(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec paraMcp(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double h3, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500, const int iteTight = 3, const double para = 3) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaMCP(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
int iteT = 1;
// Tightening
arma::vec beta0(p + 1);
while (iteT <= iteTight) {
iteT++;
beta = betaNew;
beta0 = betaNew;
Lambda = cmptLambdaMCP(beta, lambda, p, para);
phi = phi0;
ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
if (arma::norm(betaNew - beta0, "inf") <= epsilon) {
break;
}
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec paraMcpWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double h3, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500, const double para = 3) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaMCP(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammParaLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h3);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec conquerParaLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = paraLasso(Z, Y, lambda, tau, p, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerParaLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = paraLasso(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = paraLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerParaElastic(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double alpha, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = paraElastic(Z, Y, lambda, tau, alpha, p, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerParaElasticSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double alpha, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = paraElastic(Z, Y, lambdaSeq(0), tau, alpha, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = paraElasticWarm(Z, Y, lambdaSeq(i), betaWarm, tau, alpha, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerParaGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = paraGroupLasso(Z, Y, lambda, tau, group, weight, p, G, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerParaGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = paraGroupLasso(Z, Y, lambdaSeq(0), tau, group, weight, p, G, n1, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = paraGroupLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerParaSparseGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = paraSparseGroupLasso(Z, Y, lambda, tau, group, weight, p, G, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerParaSparseGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight,
const int G, const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = paraSparseGroupLasso(Z, Y, lambdaSeq(0), tau, group, weight, p, G, n1, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = paraSparseGroupLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerParaScad(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500, const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = paraScad(Z, Y, lambda, tau, p, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerParaScadSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500, const int iteTight = 3,
const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = paraScad(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = paraScadWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax, para);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerParaMcp(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500, const int iteTight = 3, const double para = 3.0) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = paraMcp(Z, Y, lambda, tau, p, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerParaMcpSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500, const int iteTight = 3, const double para = 3.0) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = paraMcp(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = paraMcpWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax, para);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
Rcpp::List cvParaLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = paraLasso(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = paraLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, h3, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = paraLasso(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = paraLasso(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvParaElasticWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const double alpha,
const int kfolds, const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = paraElastic(trainZ, trainY, lambdaSeq(0), tau, alpha, p, n1Train, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = paraElasticWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, alpha, p, n1Train, h, h1, h3, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = paraElastic(Z, Y, lambdaSeq(cvIdx), tau, alpha, p, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = paraElastic(Z, Y, lambdaSeq(seIdx), tau, alpha, p, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvParaGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = paraGroupLasso(trainZ, trainY, lambdaSeq(0), tau, group, weight, p, G, n1Train, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = paraGroupLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1Train, h, h1, h3, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = paraGroupLasso(Z, Y, lambdaSeq(cvIdx), tau, group, weight, p, G, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = paraGroupLasso(Z, Y, lambdaSeq(seIdx), tau, group, weight, p, G, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvParaSparseGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau,
const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = paraSparseGroupLasso(trainZ, trainY, lambdaSeq(0), tau, group, weight, p, G, n1Train, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = paraSparseGroupLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1Train, h, h1, h3, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = paraSparseGroupLasso(Z, Y, lambdaSeq(cvIdx), tau, group, weight, p, G, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = paraSparseGroupLasso(Z, Y, lambdaSeq(seIdx), tau, group, weight, p, G, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvParaScadWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = paraScad(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = paraScadWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, h3, phi0, gamma, epsilon, iteMax, para);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = paraScad(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = paraScad(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvParaMcpWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.5, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = paraMcp(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = paraMcpWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, h3, phi0, gamma, epsilon, iteMax, para);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = paraMcp(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = paraMcp(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
conquer/src/basicOp.h 0000644 0001762 0000144 00000002742 14217177071 014262 0 ustar ligges users #ifndef BASICOP_H
#define BASICOP_H
# include
# include
// [[Rcpp::depends(RcppArmadillo)]]
// [[Rcpp::plugins(cpp11)]]
int sgn(const double x);
double mad(const arma::vec& x);
arma::mat standardize(arma::mat X, const arma::rowvec& mx, const arma::vec& sx1, const int p);
arma::vec softThresh(const arma::vec& x, const arma::vec& Lambda, const int p);
void lossQr(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const int i, arma::vec& dev, arma::vec& devsq);
arma::vec cmptLambdaLasso(const double lambda, const int p);
double lossL2(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double n1, const double tau);
double updateL2(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double n1, const double tau);
double lammL2(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi, const double gamma,
const int p, const double n1);
arma::vec lasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double phi0 = 0.1,
const double gamma = 1.2, const double epsilon = 0.01, const int iteMax = 500);
arma::vec cmptLambdaSCAD(const arma::vec& beta, const double lambda, const int p, const double para = 3.7);
arma::vec cmptLambdaMCP(const arma::vec& beta, const double lambda, const int p, const double para = 3.0);
#endif
conquer/src/Makevars 0000644 0001762 0000144 00000000204 14370046014 014204 0 ustar ligges users
CXX_STD = CXX17
PKG_CXXFLAGS = $(SHLIB_OPENMP_CXXFLAGS)
PKG_LIBS = $(SHLIB_OPENMP_CXXFLAGS) $(LAPACK_LIBS) $(BLAS_LIBS) $(FLIBS)
conquer/src/highdUnif.cpp 0000644 0001762 0000144 00000127367 14367652026 015161 0 ustar ligges users # include
# include
# include "basicOp.h"
// [[Rcpp::depends(RcppArmadillo)]]
// [[Rcpp::plugins(cpp11)]]
// [[Rcpp::export]]
double lossUnifHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const double h, const double h1) {
arma::vec res = Y - Z * beta;
arma::vec temp = (tau - 0.5) * res;
for (int i = 0; i < res.size(); i++) {
double cur = std::abs(res(i));
temp(i) += cur <= h ? (0.25 * h1 * cur * cur + 0.25 * h) : 0.5 * cur;
}
return arma::mean(temp);
}
// [[Rcpp::export]]
double updateUnifHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double tau, const double n1, const double h,
const double h1) {
arma::vec res = Y - Z * beta;
arma::vec temp = (tau - 0.5) * res;
arma::vec der(res.size());
for (int i = 0; i < res.size(); i++) {
double cur = res(i);
if (cur <= -h) {
der(i) = 1 - tau;
temp(i) -= 0.5 * cur;
} else if (cur < h) {
der(i) = 0.5 - tau - 0.5 * h1 * cur;
temp(i) += 0.25 * h1 * cur * cur + 0.25 * h;
} else {
der(i) = -tau;
temp(i) += 0.5 * cur;
}
}
grad = n1 * Z.t() * der;
return arma::mean(temp);
}
// [[Rcpp::export]]
double lammUnifLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi,
const double gamma, const int p, const double h, const double n1, const double h1) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateUnifHd(Z, Y, beta, grad, tau, n1, h, h1);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = Lambda / phiNew;
betaNew = softThresh(first, second, p);
double fVal = lossUnifHd(Z, Y, betaNew, tau, h, h1);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammUnifElastic(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double alpha,
const double phi, const double gamma, const int p, const double h, const double n1, const double h1) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateUnifHd(Z, Y, beta, grad, tau, n1, h, h1);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = alpha * Lambda / phiNew;
betaNew = softThresh(first, second, p) / (1.0 + (2.0 - 2 * alpha) * Lambda / phiNew);
double fVal = lossUnifHd(Z, Y, betaNew, tau, h, h1);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammUnifGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, arma::vec& beta, const double tau, const arma::vec& group,
const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1,
const double h1) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateUnifHd(Z, Y, beta, grad, tau, n1, h, h1);
while (true) {
arma::vec subNorm = arma::zeros(G);
betaNew = beta - grad / phiNew;
for (int i = 1; i <= p; i++) {
subNorm(group(i)) += betaNew(i) * betaNew(i);
}
subNorm = arma::max(1.0 - lambda * weight / (phiNew * arma::sqrt(subNorm)), arma::zeros(G));
for (int i = 1; i <= p; i++) {
betaNew(i) *= subNorm(group(i));
}
double fVal = lossUnifHd(Z, Y, betaNew, tau, h, h1);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammUnifSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, const double lambda, arma::vec& beta, const double tau,
const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G,
const double h, const double n1, const double h1) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateUnifHd(Z, Y, beta, grad, tau, n1, h, h1);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = Lambda / phiNew;
betaNew = softThresh(first, second, p);
arma::vec subNorm = arma::zeros(G);
for (int i = 1; i <= p; i++) {
subNorm(group(i)) += betaNew(i) * betaNew(i);
}
subNorm = arma::max(1.0 - lambda * weight / (phiNew * arma::sqrt(subNorm)), arma::zeros(G));
for (int i = 1; i <= p; i++) {
betaNew(i) *= subNorm(group(i));
}
double fVal = lossUnifHd(Z, Y, betaNew, tau, h, h1);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
arma::vec unifLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec unifLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec unifElastic(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const double alpha, const int p, const double n1,
const double h, const double h1, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifElastic(Z, Y, Lambda, betaNew, tau, alpha, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec unifElasticWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const double alpha,
const int p, const double n1, const double h, const double h1, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifElastic(Z, Y, Lambda, betaNew, tau, alpha, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec unifGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifGroupLasso(Z, Y, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec unifGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau,
const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h,
const double h1, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifGroupLasso(Z, Y, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec unifSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifSparseGroupLasso(Z, Y, Lambda, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec unifSparseGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau,
const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h,
const double h1, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifSparseGroupLasso(Z, Y, Lambda, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec unifScad(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.7) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaSCAD(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
int iteT = 1;
// Tightening
arma::vec beta0(p + 1);
while (iteT <= iteTight) {
iteT++;
beta = betaNew;
beta0 = betaNew;
Lambda = cmptLambdaSCAD(beta, lambda, p, para);
phi = phi0;
ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
if (arma::norm(betaNew - beta0, "inf") <= epsilon) {
break;
}
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec unifScadWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500, const double para = 3.7) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaSCAD(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec unifMcp(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaMCP(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
int iteT = 1;
// Tightening
arma::vec beta0(p + 1);
while (iteT <= iteTight) {
iteT++;
beta = betaNew;
beta0 = betaNew;
Lambda = cmptLambdaMCP(beta, lambda, p, para);
phi = phi0;
ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
if (arma::norm(betaNew - beta0, "inf") <= epsilon) {
break;
}
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec unifMcpWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500, const double para = 3) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaMCP(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammUnifLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec conquerUnifLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = unifLasso(Z, Y, lambda, tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerUnifLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = unifLasso(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = unifLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerUnifElastic(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double alpha, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = unifElastic(Z, Y, lambda, tau, alpha, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerUnifElasticSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double alpha, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = unifElastic(Z, Y, lambdaSeq(0), tau, alpha, p, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = unifElasticWarm(Z, Y, lambdaSeq(i), betaWarm, tau, alpha, p, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerUnifGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = unifGroupLasso(Z, Y, lambda, tau, group, weight, p, G, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerUnifGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = unifGroupLasso(Z, Y, lambdaSeq(0), tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = unifGroupLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerUnifSparseGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = unifSparseGroupLasso(Z, Y, lambda, tau, group, weight, p, G, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerUnifSparseGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight,
const int G, const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = unifSparseGroupLasso(Z, Y, lambdaSeq(0), tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = unifSparseGroupLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerUnifScad(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500, const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = unifScad(Z, Y, lambda, tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerUnifScadSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = unifScad(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = unifScadWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, para);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerUnifMcp(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500, const int iteTight = 3, const double para = 3.0) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = unifMcp(Z, Y, lambda, tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerUnifMcpSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.0) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = unifMcp(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = unifMcpWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, para);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
Rcpp::List cvUnifLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h;
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = unifLasso(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = unifLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = unifLasso(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = unifLasso(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvUnifElasticWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const double alpha,
const int kfolds, const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h;
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = unifElastic(trainZ, trainY, lambdaSeq(0), tau, alpha, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = unifElasticWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, alpha, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = unifElastic(Z, Y, lambdaSeq(cvIdx), tau, alpha, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = unifElastic(Z, Y, lambdaSeq(seIdx), tau, alpha, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvUnifGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h;
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = unifGroupLasso(trainZ, trainY, lambdaSeq(0), tau, group, weight, p, G, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = unifGroupLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = unifGroupLasso(Z, Y, lambdaSeq(cvIdx), tau, group, weight, p, G, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = unifGroupLasso(Z, Y, lambdaSeq(seIdx), tau, group, weight, p, G, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvUnifSparseGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau,
const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h;
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = unifSparseGroupLasso(trainZ, trainY, lambdaSeq(0), tau, group, weight, p, G, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = unifSparseGroupLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = unifSparseGroupLasso(Z, Y, lambdaSeq(cvIdx), tau, group, weight, p, G, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = unifSparseGroupLasso(Z, Y, lambdaSeq(seIdx), tau, group, weight, p, G, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvUnifScadWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h;
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = unifScad(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = unifScadWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax, para);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = unifScad(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = unifScad(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvUnifMcpWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.5, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h;
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = unifMcp(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = unifMcpWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax, para);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = unifMcp(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = unifMcp(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
conquer/src/Makevars.win 0000644 0001762 0000144 00000000204 14370046016 015002 0 ustar ligges users
CXX_STD = CXX17
PKG_CXXFLAGS = $(SHLIB_OPENMP_CXXFLAGS)
PKG_LIBS = $(SHLIB_OPENMP_CXXFLAGS) $(LAPACK_LIBS) $(BLAS_LIBS) $(FLIBS)
conquer/src/defFun.cpp 0000644 0001762 0000144 00000010264 14217200556 014435 0 ustar ligges users # include
# include
# include "basicOp.h"
// [[Rcpp::depends(RcppArmadillo)]]
// [[Rcpp::plugins(cpp11)]]
// [[Rcpp::export]]
int sgn(const double x) {
return (x > 0) - (x < 0);
}
// [[Rcpp::export]]
double mad(const arma::vec& x) {
return 1.482602 * arma::median(arma::abs(x - arma::median(x)));
}
// [[Rcpp::export]]
arma::mat standardize(arma::mat X, const arma::rowvec& mx, const arma::vec& sx1, const int p) {
for (int i = 0; i < p; i++) {
X.col(i) = (X.col(i) - mx(i)) * sx1(i);
}
return X;
}
// [[Rcpp::export]]
arma::vec softThresh(const arma::vec& x, const arma::vec& Lambda, const int p) {
return arma::sign(x) % arma::max(arma::abs(x) - Lambda, arma::zeros(p + 1));
}
// [[Rcpp::export]]
void lossQr(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const int i, arma::vec& dev, arma::vec& devsq) {
arma::vec res = Y - Z * beta;
for (int k = 0; k < res.size(); k++) {
double temp = res(k) >= 0 ? tau * res(k) : (tau - 1) * res(k);
dev(i) += temp;
devsq(i) += temp * temp;
}
}
// [[Rcpp::export]]
arma::vec cmptLambdaLasso(const double lambda, const int p) {
arma::vec rst = lambda * arma::ones(p + 1);
rst(0) = 0;
return rst;
}
// [[Rcpp::export]]
double lossL2(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double n1, const double tau) {
arma::vec res = Y - Z * beta;
double rst = 0.0;
for (int i = 0; i < Y.size(); i++) {
rst += (res(i) > 0) ? (tau * res(i) * res(i)) : ((1 - tau) * res(i) * res(i));
}
return 0.5 * n1 * rst;
}
// [[Rcpp::export]]
double updateL2(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double n1, const double tau) {
arma::vec res = Y - Z * beta;
double rst = 0.0;
grad = arma::zeros(grad.size());
for (int i = 0; i < Y.size(); i++) {
double temp = res(i) > 0 ? tau : (1 - tau);
grad -= temp * res(i) * Z.row(i).t();
rst += temp * res(i) * res(i);
}
grad *= n1;
return 0.5 * n1 * rst;
}
// LAMM code for initialization
// [[Rcpp::export]]
double lammL2(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi, const double gamma,
const int p, const double n1) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateL2(Z, Y, beta, grad, n1, tau);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = Lambda / phiNew;
betaNew = softThresh(first, second, p);
double fVal = lossL2(Z, Y, betaNew, n1, tau);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
arma::vec lasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double phi0,
const double gamma, const double epsilon, const int iteMax) {
arma::vec beta = arma::zeros(p + 1);
arma::vec betaNew = arma::zeros(p + 1);
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammL2(Z, Y, Lambda, betaNew, tau, phi, gamma, p, n1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec cmptLambdaSCAD(const arma::vec& beta, const double lambda, const int p, const double para) {
arma::vec rst = arma::zeros(p + 1);
for (int i = 1; i <= p; i++) {
double abBeta = std::abs(beta(i));
if (abBeta <= lambda) {
rst(i) = lambda;
} else if (abBeta <= para * lambda) {
rst(i) = (para * lambda - abBeta) / (para - 1);
}
}
return rst;
}
// [[Rcpp::export]]
arma::vec cmptLambdaMCP(const arma::vec& beta, const double lambda, const int p, const double para) {
arma::vec rst = arma::zeros(p + 1);
for (int i = 1; i <= p; i++) {
double abBeta = std::abs(beta(i));
if (abBeta <= para * lambda) {
rst(i) = lambda - abBeta / para;
}
}
return rst;
}
conquer/src/highdGauss.cpp 0000644 0001762 0000144 00000131441 14367651101 015317 0 ustar ligges users # include
# include
# include "basicOp.h"
// [[Rcpp::depends(RcppArmadillo)]]
// [[Rcpp::plugins(cpp11)]]
// [[Rcpp::export]]
double lossGaussHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const double h, const double h1, const double h2) {
arma::vec res = Y - Z * beta;
arma::vec temp = 0.3989423 * h * arma::exp(-0.5 * h2 * arma::square(res)) + tau * res - res % arma::normcdf(-h1 * res);
return arma::mean(temp);
}
// [[Rcpp::export]]
double updateGaussHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double tau, const double n1, const double h,
const double h1, const double h2) {
arma::vec res = Y - Z * beta;
arma::vec der = arma::normcdf(-h1 * res) - tau;
grad = n1 * Z.t() * der;
arma::vec temp = 0.3989423 * h * arma::exp(-0.5 * h2 * arma::square(res)) + tau * res - res % arma::normcdf(-h1 * res);
return arma::mean(temp);
}
// [[Rcpp::export]]
double lammGaussLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi,
const double gamma, const int p, const double h, const double n1, const double h1, const double h2) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateGaussHd(Z, Y, beta, grad, tau, n1, h, h1, h2);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = Lambda / phiNew;
betaNew = softThresh(first, second, p);
double fVal = lossGaussHd(Z, Y, betaNew, tau, h, h1, h2);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammGaussElastic(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double alpha,
const double phi, const double gamma, const int p, const double h, const double n1, const double h1, const double h2) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateGaussHd(Z, Y, beta, grad, tau, n1, h, h1, h2);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = alpha * Lambda / phiNew;
betaNew = softThresh(first, second, p) / (1.0 + (2.0 - 2 * alpha) * Lambda / phiNew);
double fVal = lossGaussHd(Z, Y, betaNew, tau, h, h1, h2);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammGaussGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, arma::vec& beta, const double tau, const arma::vec& group,
const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1,
const double h1, const double h2) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateGaussHd(Z, Y, beta, grad, tau, n1, h, h1, h2);
while (true) {
arma::vec subNorm = arma::zeros(G);
betaNew = beta - grad / phiNew;
for (int i = 1; i <= p; i++) {
subNorm(group(i)) += betaNew(i) * betaNew(i);
}
subNorm = arma::max(1.0 - lambda * weight / (phiNew * arma::sqrt(subNorm)), arma::zeros(G));
for (int i = 1; i <= p; i++) {
betaNew(i) *= subNorm(group(i));
}
double fVal = lossGaussHd(Z, Y, betaNew, tau, h, h1, h2);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammGaussSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, const double lambda, arma::vec& beta, const double tau,
const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G,
const double h, const double n1, const double h1, const double h2) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateGaussHd(Z, Y, beta, grad, tau, n1, h, h1, h2);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = Lambda / phiNew;
betaNew = softThresh(first, second, p);
arma::vec subNorm = arma::zeros(G);
for (int i = 1; i <= p; i++) {
subNorm(group(i)) += betaNew(i) * betaNew(i);
}
subNorm = arma::max(1.0 - lambda * weight / (phiNew * arma::sqrt(subNorm)), arma::zeros(G));
for (int i = 1; i <= p; i++) {
betaNew(i) *= subNorm(group(i));
}
double fVal = lossGaussHd(Z, Y, betaNew, tau, h, h1, h2);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// High-dim conquer with a standardized design matrix and a given lambda
// [[Rcpp::export]]
arma::vec gaussLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec gaussLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec gaussElastic(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const double alpha, const int p, const double n1,
const double h, const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussElastic(Z, Y, Lambda, betaNew, tau, alpha, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec gaussElasticWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const double alpha,
const int p, const double n1, const double h, const double h1, const double h2, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussElastic(Z, Y, Lambda, betaNew, tau, alpha, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec gaussGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussGroupLasso(Z, Y, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec gaussGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau,
const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h,
const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussGroupLasso(Z, Y, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec gaussSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussSparseGroupLasso(Z, Y, Lambda, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec gaussSparseGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussSparseGroupLasso(Z, Y, Lambda, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec gaussScad(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500, const int iteTight = 3, const double para = 3.7) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaSCAD(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
int iteT = 1;
// Tightening
arma::vec beta0(p + 1);
while (iteT <= iteTight) {
iteT++;
beta = betaNew;
beta0 = betaNew;
Lambda = cmptLambdaSCAD(beta, lambda, p, para);
phi = phi0;
ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
if (arma::norm(betaNew - beta0, "inf") <= epsilon) {
break;
}
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec gaussScadWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500, const double para = 3.7) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaSCAD(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec gaussMcp(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500, const int iteTight = 3, const double para = 3) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaMCP(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
int iteT = 1;
// Tightening
arma::vec beta0(p + 1);
while (iteT <= iteTight) {
iteT++;
beta = betaNew;
beta0 = betaNew;
Lambda = cmptLambdaMCP(beta, lambda, p, para);
phi = phi0;
ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
if (arma::norm(betaNew - beta0, "inf") <= epsilon) {
break;
}
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec gaussMcpWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double h2, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500, const double para = 3) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaMCP(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammGaussLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1, h2);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// high-dim conquer with a specified lambda or a sequence of lambda
// [[Rcpp::export]]
arma::vec conquerGaussLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = gaussLasso(Z, Y, lambda, tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerGaussLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = gaussLasso(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = gaussLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerGaussElastic(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double alpha, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = gaussElastic(Z, Y, lambda, tau, alpha, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerGaussElasticSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double alpha, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = gaussElastic(Z, Y, lambdaSeq(0), tau, alpha, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = gaussElasticWarm(Z, Y, lambdaSeq(i), betaWarm, tau, alpha, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerGaussGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = gaussGroupLasso(Z, Y, lambda, tau, group, weight, p, G, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerGaussGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = gaussGroupLasso(Z, Y, lambdaSeq(0), tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = gaussGroupLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerGaussSparseGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = gaussSparseGroupLasso(Z, Y, lambda, tau, group, weight, p, G, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerGaussSparseGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight,
const int G, const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = gaussSparseGroupLasso(Z, Y, lambdaSeq(0), tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = gaussSparseGroupLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerGaussScad(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500, const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = gaussScad(Z, Y, lambda, tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerGaussScadSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = gaussScad(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = gaussScadWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, para);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerGaussMcp(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500, const int iteTight = 3, const double para = 3.0) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = gaussMcp(Z, Y, lambda, tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerGaussMcpSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.0) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h), n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = gaussMcp(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = gaussMcpWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, para);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// cross-validation, the range of lambda is guided by the simulation-based mathod in Belloni & Chernozhukov (2011), AOS
// [[Rcpp::export]]
Rcpp::List cvGaussLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = gaussLasso(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = gaussLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = gaussLasso(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = gaussLasso(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvGaussElasticWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const double alpha,
const int kfolds, const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = gaussElastic(trainZ, trainY, lambdaSeq(0), tau, alpha, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = gaussElasticWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, alpha, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = gaussElastic(Z, Y, lambdaSeq(cvIdx), tau, alpha, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = gaussElastic(Z, Y, lambdaSeq(seIdx), tau, alpha, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvGaussGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = gaussGroupLasso(trainZ, trainY, lambdaSeq(0), tau, group, weight, p, G, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = gaussGroupLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = gaussGroupLasso(Z, Y, lambdaSeq(cvIdx), tau, group, weight, p, G, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = gaussGroupLasso(Z, Y, lambdaSeq(seIdx), tau, group, weight, p, G, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvGaussSparseGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau,
const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = gaussSparseGroupLasso(trainZ, trainY, lambdaSeq(0), tau, group, weight, p, G, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = gaussSparseGroupLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = gaussSparseGroupLasso(Z, Y, lambdaSeq(cvIdx), tau, group, weight, p, G, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = gaussSparseGroupLasso(Z, Y, lambdaSeq(seIdx), tau, group, weight, p, G, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvGaussScadWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = gaussScad(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = gaussScadWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax, para);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = gaussScad(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = gaussScad(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvGaussMcpWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.5, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = gaussMcp(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = gaussMcpWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, h2, phi0, gamma, epsilon, iteMax, para);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = gaussMcp(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = gaussMcp(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
conquer/src/highdLogistic.cpp 0000644 0001762 0000144 00000127757 14367651321 016035 0 ustar ligges users # include
# include
# include "basicOp.h"
// [[Rcpp::depends(RcppArmadillo)]]
// [[Rcpp::plugins(cpp11)]]
// [[Rcpp::export]]
double lossLogisticHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const double h, const double h1) {
arma::vec res = Y - Z * beta;
arma::vec temp = tau * res + h * arma::log(1.0 + arma::exp(-h1 * res));
return arma::mean(temp);
}
// [[Rcpp::export]]
double updateLogisticHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double tau, const double n1, const double h,
const double h1) {
arma::vec res = Y - Z * beta;
arma::vec der = 1.0 / (1.0 + arma::exp(res * h1)) - tau;
grad = n1 * Z.t() * der;
arma::vec temp = tau * res + h * arma::log(1.0 + arma::exp(-h1 * res));
return arma::mean(temp);
}
// [[Rcpp::export]]
double lammLogisticLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi,
const double gamma, const int p, const double h, const double n1, const double h1) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateLogisticHd(Z, Y, beta, grad, tau, n1, h, h1);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = Lambda / phiNew;
betaNew = softThresh(first, second, p);
double fVal = lossLogisticHd(Z, Y, betaNew, tau, h, h1);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammLogisticElastic(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double alpha,
const double phi, const double gamma, const int p, const double h, const double n1, const double h1) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateLogisticHd(Z, Y, beta, grad, tau, n1, h, h1);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = alpha * Lambda / phiNew;
betaNew = softThresh(first, second, p) / (1.0 + (2.0 - 2 * alpha) * Lambda / phiNew);
double fVal = lossLogisticHd(Z, Y, betaNew, tau, h, h1);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammLogisticGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, arma::vec& beta, const double tau, const arma::vec& group,
const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1,
const double h1) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateLogisticHd(Z, Y, beta, grad, tau, n1, h, h1);
while (true) {
arma::vec subNorm = arma::zeros(G);
betaNew = beta - grad / phiNew;
for (int i = 1; i <= p; i++) {
subNorm(group(i)) += betaNew(i) * betaNew(i);
}
subNorm = arma::max(1.0 - lambda * weight / (phiNew * arma::sqrt(subNorm)), arma::zeros(G));
for (int i = 1; i <= p; i++) {
betaNew(i) *= subNorm(group(i));
}
double fVal = lossLogisticHd(Z, Y, betaNew, tau, h, h1);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
double lammLogisticSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, const double lambda, arma::vec& beta, const double tau,
const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G,
const double h, const double n1, const double h1) {
double phiNew = phi;
arma::vec betaNew(p + 1);
arma::vec grad(p + 1);
double loss = updateLogisticHd(Z, Y, beta, grad, tau, n1, h, h1);
while (true) {
arma::vec first = beta - grad / phiNew;
arma::vec second = Lambda / phiNew;
betaNew = softThresh(first, second, p);
arma::vec subNorm = arma::zeros(G);
for (int i = 1; i <= p; i++) {
subNorm(group(i)) += betaNew(i) * betaNew(i);
}
subNorm = arma::max(1.0 - lambda * weight / (phiNew * arma::sqrt(subNorm)), arma::zeros(G));
for (int i = 1; i <= p; i++) {
betaNew(i) *= subNorm(group(i));
}
double fVal = lossLogisticHd(Z, Y, betaNew, tau, h, h1);
arma::vec diff = betaNew - beta;
double psiVal = loss + arma::as_scalar(grad.t() * diff) + 0.5 * phiNew * arma::as_scalar(diff.t() * diff);
if (fVal <= psiVal) {
break;
}
phiNew *= gamma;
}
beta = betaNew;
return phiNew;
}
// [[Rcpp::export]]
arma::vec logisticLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec logisticLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec logisticElastic(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const double alpha, const int p, const double n1,
const double h, const double h1, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaLasso(lambda, p);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticElastic(Z, Y, Lambda, betaNew, tau, alpha, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec logisticElasticWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const double alpha,
const int p, const double n1, const double h, const double h1, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticElastic(Z, Y, Lambda, betaNew, tau, alpha, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec logisticGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticGroupLasso(Z, Y, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec logisticGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau,
const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h,
const double h1, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticGroupLasso(Z, Y, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec logisticSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group,
const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticSparseGroupLasso(Z, Y, Lambda, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec logisticSparseGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau,
const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h,
const double h1, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = lambda * arma::ones(p + 1);
Lambda(0) = 0;
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticSparseGroupLasso(Z, Y, Lambda, lambda, betaNew, tau, group, weight, phi, gamma, p, G, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec logisticScad(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.7) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaSCAD(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
int iteT = 1;
// Tightening
arma::vec beta0(p + 1);
while (iteT <= iteTight) {
iteT++;
beta = betaNew;
beta0 = betaNew;
Lambda = cmptLambdaSCAD(beta, lambda, p, para);
phi = phi0;
ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
if (arma::norm(betaNew - beta0, "inf") <= epsilon) {
break;
}
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec logisticScadWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500, const double para = 3.7) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaSCAD(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec logisticMcp(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h,
const double h1, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3) {
arma::vec beta = lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec betaNew = beta;
// Contraction
arma::vec Lambda = cmptLambdaMCP(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
int iteT = 1;
// Tightening
arma::vec beta0(p + 1);
while (iteT <= iteTight) {
iteT++;
beta = betaNew;
beta0 = betaNew;
Lambda = cmptLambdaMCP(beta, lambda, p, para);
phi = phi0;
ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
if (arma::norm(betaNew - beta0, "inf") <= epsilon) {
break;
}
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec logisticMcpWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p,
const double n1, const double h, const double h1, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500, const double para = 3) {
arma::vec beta = betaWarm;
arma::vec betaNew = beta;
arma::vec Lambda = cmptLambdaMCP(beta, lambda, p, para);
double phi = phi0;
int ite = 0;
while (ite <= iteMax) {
ite++;
phi = lammLogisticLasso(Z, Y, Lambda, betaNew, tau, phi, gamma, p, h, n1, h1);
phi = std::max(phi0, phi / gamma);
if (arma::norm(betaNew - beta, "inf") <= epsilon) {
break;
}
beta = betaNew;
}
return betaNew;
}
// [[Rcpp::export]]
arma::vec conquerLogisticLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = logisticLasso(Z, Y, lambda, tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerLogisticLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = logisticLasso(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = logisticLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerLogisticElastic(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double alpha, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = logisticElastic(Z, Y, lambda, tau, alpha, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerLogisticElasticSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double alpha, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = logisticElastic(Z, Y, lambdaSeq(0), tau, alpha, p, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = logisticElasticWarm(Z, Y, lambdaSeq(i), betaWarm, tau, alpha, p, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerLogisticGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = logisticGroupLasso(Z, Y, lambda, tau, group, weight, p, G, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerLogisticGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = logisticGroupLasso(Z, Y, lambdaSeq(0), tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = logisticGroupLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerLogisticSparseGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = logisticSparseGroupLasso(Z, Y, lambda, tau, group, weight, p, G, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerLogisticSparseGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight,
const int G, const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = logisticSparseGroupLasso(Z, Y, lambdaSeq(0), tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = logisticSparseGroupLassoWarm(Z, Y, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerLogisticScad(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500, const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = logisticScad(Z, Y, lambda, tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerLogisticScadSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = logisticScad(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = logisticScadWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, para);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
arma::vec conquerLogisticMcp(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500, const int iteTight = 3, const double para = 3.0) {
const int n = X.n_rows, p = X.n_cols;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec betaHat = logisticMcp(Z, Y, lambda, tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
return betaHat;
}
// [[Rcpp::export]]
arma::mat conquerLogisticMcpSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h,
const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.0) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h, n1 = 1.0 / n;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::mat betaSeq(p + 1, nlambda);
arma::vec betaHat = logisticMcp(Z, Y, lambdaSeq(0), tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaSeq.col(0) = betaHat;
arma::vec betaWarm = betaHat;
for (int i = 1; i < nlambda; i++) {
betaHat = logisticMcpWarm(Z, Y, lambdaSeq(i), betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, para);
betaSeq.col(i) = betaHat;
betaWarm = betaHat;
}
betaSeq.rows(1, p).each_col() %= sx1;
betaSeq.row(0) += my - mx * betaSeq.rows(1, p);
return betaSeq;
}
// [[Rcpp::export]]
Rcpp::List cvLogisticLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h;
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = logisticLasso(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = logisticLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = logisticLasso(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = logisticLasso(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvLogisticElasticWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const double alpha,
const int kfolds, const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001,
const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h;
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = logisticElastic(trainZ, trainY, lambdaSeq(0), tau, alpha, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = logisticElasticWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, alpha, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = logisticElastic(Z, Y, lambdaSeq(cvIdx), tau, alpha, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = logisticElastic(Z, Y, lambdaSeq(seIdx), tau, alpha, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvLogisticGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0 = 0.01, const double gamma = 1.2,
const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h;
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = logisticGroupLasso(trainZ, trainY, lambdaSeq(0), tau, group, weight, p, G, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = logisticGroupLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = logisticGroupLasso(Z, Y, lambdaSeq(cvIdx), tau, group, weight, p, G, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = logisticGroupLasso(Z, Y, lambdaSeq(seIdx), tau, group, weight, p, G, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvLogisticSparseGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau,
const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0 = 0.01,
const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h;
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = logisticSparseGroupLasso(trainZ, trainY, lambdaSeq(0), tau, group, weight, p, G, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = logisticSparseGroupLassoWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, group, weight, p, G, n1Train, h, h1, phi0, gamma, epsilon, iteMax);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = logisticSparseGroupLasso(Z, Y, lambdaSeq(cvIdx), tau, group, weight, p, G, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = logisticSparseGroupLasso(Z, Y, lambdaSeq(seIdx), tau, group, weight, p, G, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvLogisticScadWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.2, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3.7) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h;
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = logisticScad(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = logisticScadWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax, para);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = logisticScad(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = logisticScad(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
// [[Rcpp::export]]
Rcpp::List cvLogisticMcpWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds,
const double h, const double phi0 = 0.01, const double gamma = 1.5, const double epsilon = 0.001, const int iteMax = 500,
const int iteTight = 3, const double para = 3) {
const int n = X.n_rows, p = X.n_cols, nlambda = lambdaSeq.size();
const double h1 = 1.0 / h;
arma::vec betaHat(p + 1), betaWarm(p + 1);
arma::vec dev = arma::zeros(nlambda);
arma::vec devsq = arma::zeros(nlambda);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
for (int j = 1; j <= kfolds; j++) {
arma::uvec idx = arma::find(folds == j);
arma::uvec idxComp = arma::find(folds != j);
double n1Train = 1.0 / idxComp.size();
arma::mat trainZ = Z.rows(idxComp), testZ = Z.rows(idx);
arma::vec trainY = Y.rows(idxComp), testY = Y.rows(idx);
betaHat = logisticMcp(trainZ, trainY, lambdaSeq(0), tau, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaWarm = betaHat;
lossQr(testZ, testY, betaHat, tau, 0, dev, devsq);
for (int i = 1; i < nlambda; i++) {
betaHat = logisticMcpWarm(trainZ, trainY, lambdaSeq(i), betaWarm, tau, p, n1Train, h, h1, phi0, gamma, epsilon, iteMax, para);
lossQr(testZ, testY, betaHat, tau, i, dev, devsq);
betaWarm = betaHat;
}
}
dev /= n;
devsq = arma::sqrt(devsq - n * arma::square(dev)) / n;
arma::uword cvIdx = arma::index_min(dev);
betaHat = logisticMcp(Z, Y, lambdaSeq(cvIdx), tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHat.rows(1, p) %= sx1;
betaHat(0) += my - arma::as_scalar(mx * betaHat.rows(1, p));
arma::uword seIdx = arma::max(arma::find(dev <= dev(cvIdx) + devsq(cvIdx)));
arma::vec betaHatSe = logisticMcp(Z, Y, lambdaSeq(seIdx), tau, p, 1.0 / n, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para);
betaHatSe.rows(1, p) %= sx1;
betaHatSe(0) += my - arma::as_scalar(mx * betaHatSe.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = betaHat, Rcpp::Named("coeffSe") = betaHatSe, Rcpp::Named("lambdaMin") = lambdaSeq(cvIdx),
Rcpp::Named("lambdaSe") = lambdaSeq(seIdx), Rcpp::Named("deviance") = dev, Rcpp::Named("devianceSd") = devsq);
}
conquer/src/lowd.cpp 0000644 0001762 0000144 00000255246 14401302757 014207 0 ustar ligges users # include
# include
# include "basicOp.h"
// [[Rcpp::depends(RcppArmadillo)]]
// [[Rcpp::plugins(cpp11)]]
// Asymmetric huber regression adjusted to quantile tau for initialization
// [[Rcpp::export]]
void updateHuber(const arma::mat& Z, const arma::vec& res, const double tau, arma::vec& der, arma::vec& grad, const int n, const double rob, const double n1) {
for (int i = 0; i < n; i++) {
double cur = res(i);
if (cur > rob) {
der(i) = -2 * tau * rob;
} else if (cur > 0) {
der(i) = -2 * tau * cur;
} else if (cur > -rob) {
der(i) = 2 * (tau - 1) * cur;
} else {
der(i) = 2 * (1 - tau) * rob;
}
}
grad = n1 * Z.t() * der;
}
// Different kernels for low-dimensional conquer
// [[Rcpp::export]]
void updateGauss(const arma::mat& Z, const arma::vec& res, arma::vec& der, arma::vec& grad, const double tau, const double n1, const double h1) {
der = arma::normcdf(-res * h1) - tau;
grad = n1 * Z.t() * der;
}
// [[Rcpp::export]]
void updateLogistic(const arma::mat& Z, const arma::vec& res, arma::vec& der, arma::vec& grad, const double tau, const double n1, const double h1) {
der = 1.0 / (1.0 + arma::exp(res * h1)) - tau;
grad = n1 * Z.t() * der;
}
// [[Rcpp::export]]
void updateUnif(const arma::mat& Z, const arma::vec& res, arma::vec& der, arma::vec& grad, const int n, const double tau, const double h,
const double n1, const double h1) {
for (int i = 0; i < n; i++) {
double cur = res(i);
if (cur <= -h) {
der(i) = 1 - tau;
} else if (cur < h) {
der(i) = 0.5 - tau - 0.5 * h1 * cur;
} else {
der(i) = -tau;
}
}
grad = n1 * Z.t() * der;
}
// [[Rcpp::export]]
void updatePara(const arma::mat& Z, const arma::vec& res, arma::vec& der, arma::vec& grad, const int n, const double tau, const double h,
const double n1, const double h1, const double h3) {
for (int i = 0; i < n; i++) {
double cur = res(i);
if (cur <= -h) {
der(i) = 1 - tau;
} else if (cur < h) {
der(i) = 0.5 - tau - 0.75 * h1 * cur + 0.25 * h3 * cur * cur * cur;
} else {
der(i) = -tau;
}
}
grad = n1 * Z.t() * der;
}
// [[Rcpp::export]]
void updateTrian(const arma::mat& Z, const arma::vec& res, arma::vec& der, arma::vec& grad, const int n, const double tau, const double h,
const double n1, const double h1, const double h2) {
for (int i = 0; i < n; i++) {
double cur = res(i);
if (cur <= -h) {
der(i) = 1 - tau;
} else if (cur < 0) {
der(i) = 0.5 - tau - h1 * cur - 0.5 * h2 * cur * cur;
} else if (cur < h) {
der(i) = 0.5 - tau - h1 * cur + 0.5 * h2 * cur * cur;
} else {
der(i) = -tau;
}
}
grad = n1 * Z.t() * der;
}
// Functions with an upper bound for the GD step size.
// [[Rcpp::export]]
arma::vec huberReg(const arma::mat& Z, const arma::vec& Y, const double tau, arma::vec& der, arma::vec& gradOld, arma::vec& gradNew, const int n, const int p,
const double n1, const double tol = 0.0001, const double constTau = 1.345, const int iteMax = 5000, const double stepMax = 100.0) {
double rob = constTau * mad(Y);
updateHuber(Z, Y, tau, der, gradOld, n, rob, n1);
arma::vec beta = -gradOld, betaDiff = -gradOld;
arma::vec res = Y - Z * beta;
rob = constTau * mad(res);
updateHuber(Z, res, tau, der, gradNew, n, rob, n1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
rob = constTau * mad(res);
updateHuber(Z, res, tau, der, gradNew, n, rob, n1);
gradDiff = gradNew - gradOld;
ite++;
}
return beta;
}
// Low-dimensional conquer: estimation
// [[Rcpp::export]]
Rcpp::List smqrGauss(const arma::mat& X, arma::vec Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
const int p = X.n_cols;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateGauss(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrGaussNsd(const arma::mat& Z, const arma::vec& Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = Z.n_rows;
const int p = Z.n_cols - 1;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateGauss(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
arma::vec smqrGaussIni(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau = 0.5, double h = 0.05,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = betaHat;
arma::vec res = Y - Z * beta;
updateGauss(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return beta;
}
// [[Rcpp::export]]
Rcpp::List smqrLogistic(const arma::mat& X, arma::vec Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
const int p = X.n_cols;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateLogistic(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrLogisticNsd(const arma::mat& Z, const arma::vec& Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = Z.n_rows;
const int p = Z.n_cols - 1;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateLogistic(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
arma::vec smqrLogisticIni(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau = 0.5, double h = 0.05,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = betaHat;
arma::vec res = Y - Z * beta;
updateLogistic(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return beta;
}
// [[Rcpp::export]]
Rcpp::List smqrUnif(const arma::mat& X, arma::vec Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
const int p = X.n_cols;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateUnif(Z, res, der, gradOld, n, tau, h, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradNew, n, tau, h, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradNew, n, tau, h, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrUnifNsd(const arma::mat& Z, const arma::vec& Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = Z.n_rows;
const int p = Z.n_cols - 1;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateUnif(Z, res, der, gradOld, n, tau, h, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradNew, n, tau, h, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradNew, n, tau, h, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
arma::vec smqrUnifIni(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau = 0.5, double h = 0.05,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = betaHat;
arma::vec res = Y - Z * beta;
updateUnif(Z, res, der, gradOld, n, tau, h, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradNew, n, tau, h, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradNew, n, tau, h, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return beta;
}
// [[Rcpp::export]]
Rcpp::List smqrPara(const arma::mat& X, arma::vec Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
const int p = X.n_cols;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updatePara(Z, res, der, gradOld, n, tau, h, n1, h1, h3);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updatePara(Z, res, der, gradNew, n, tau, h, n1, h1, h3);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updatePara(Z, res, der, gradNew, n, tau, h, n1, h1, h3);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrParaNsd(const arma::mat& Z, const arma::vec& Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = Z.n_rows;
const int p = Z.n_cols - 1;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updatePara(Z, res, der, gradOld, n, tau, h, n1, h1, h3);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updatePara(Z, res, der, gradNew, n, tau, h, n1, h1, h3);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updatePara(Z, res, der, gradNew, n, tau, h, n1, h1, h3);
gradDiff = gradNew - gradOld;
ite++;
}
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
arma::vec smqrParaIni(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau = 0.5, double h = 0.05,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = betaHat;
arma::vec res = Y - Z * beta;
updatePara(Z, res, der, gradOld, n, tau, h, n1, h1, h3);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updatePara(Z, res, der, gradNew, n, tau, h, n1, h1, h3);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updatePara(Z, res, der, gradNew, n, tau, h, n1, h1, h3);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return beta;
}
// [[Rcpp::export]]
Rcpp::List smqrTrian(const arma::mat& X, arma::vec Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
const int p = X.n_cols;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateTrian(Z, res, der, gradOld, n, tau, h, n1, h1, h2);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradNew, n, tau, h, n1, h1, h2);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradNew, n, tau, h, n1, h1, h2);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrTrianNsd(const arma::mat& Z, const arma::vec& Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = Z.n_rows;
const int p = Z.n_cols - 1;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateTrian(Z, res, der, gradOld, n, tau, h, n1, h1, h2);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradNew, n, tau, h, n1, h1, h2);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradNew, n, tau, h, n1, h1, h2);
gradDiff = gradNew - gradOld;
ite++;
}
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
arma::vec smqrTrianIni(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau = 0.5, double h = 0.05,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = betaHat;
arma::vec res = Y - Z * beta;
updateTrian(Z, res, der, gradOld, n, tau, h, n1, h1, h2);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradNew, n, tau, h, n1, h1, h2);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradNew, n, tau, h, n1, h1, h2);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return beta;
}
// Global conquer process with a quantile grid
// [[Rcpp::export]]
Rcpp::List smqrGaussProc(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
const int p = X.n_cols;
const int m = tauSeq.size();
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::mat betaProc(p + 1, m);
for (int i = 0; i < m; i++) {
double tau = tauSeq(i);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateGauss(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
betaProc.col(i) = beta;
}
betaProc.rows(1, p).each_col() %= sx1;
betaProc.row(0) += my - mx * betaProc.rows(1, p);
return Rcpp::List::create(Rcpp::Named("coeff") = betaProc, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrLogisticProc(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
const int p = X.n_cols;
const int m = tauSeq.size();
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::mat betaProc(p + 1, m);
for (int i = 0; i < m; i++) {
double tau = tauSeq(i);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateLogistic(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
betaProc.col(i) = beta;
}
betaProc.rows(1, p).each_col() %= sx1;
betaProc.row(0) += my - mx * betaProc.rows(1, p);
return Rcpp::List::create(Rcpp::Named("coeff") = betaProc, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrUnifProc(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
const int p = X.n_cols;
const int m = tauSeq.size();
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::mat betaProc(p + 1, m);
for (int i = 0; i < m; i++) {
double tau = tauSeq(i);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateUnif(Z, res, der, gradOld, n, tau, h, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradOld, n, tau, h, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradOld, n, tau, h, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
betaProc.col(i) = beta;
}
betaProc.rows(1, p).each_col() %= sx1;
betaProc.row(0) += my - mx * betaProc.rows(1, p);
return Rcpp::List::create(Rcpp::Named("coeff") = betaProc, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrParaProc(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
const int p = X.n_cols;
const int m = tauSeq.size();
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::mat betaProc(p + 1, m);
for (int i = 0; i < m; i++) {
double tau = tauSeq(i);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updatePara(Z, res, der, gradOld, n, tau, h, n1, h1, h3);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updatePara(Z, res, der, gradOld, n, tau, h, n1, h1, h3);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updatePara(Z, res, der, gradOld, n, tau, h, n1, h1, h3);
gradDiff = gradNew - gradOld;
ite++;
}
betaProc.col(i) = beta;
}
betaProc.rows(1, p).each_col() %= sx1;
betaProc.row(0) += my - mx * betaProc.rows(1, p);
return Rcpp::List::create(Rcpp::Named("coeff") = betaProc, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrTrianProc(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
const int n = X.n_rows;
const int p = X.n_cols;
const int m = tauSeq.size();
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::mat betaProc(p + 1, m);
for (int i = 0; i < m; i++) {
double tau = tauSeq(i);
arma::vec beta = huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateTrian(Z, res, der, gradOld, n, tau, h, n1, h1, h2);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradOld, n, tau, h, n1, h1, h2);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(std::min(a1, a2), stepMax);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradOld, n, tau, h, n1, h1, h2);
gradDiff = gradNew - gradOld;
ite++;
}
betaProc.col(i) = beta;
}
betaProc.rows(1, p).each_col() %= sx1;
betaProc.row(0) += my - mx * betaProc.rows(1, p);
return Rcpp::List::create(Rcpp::Named("coeff") = betaProc, Rcpp::Named("bandwidth") = h);
}
// Conquer with bootstrap inference
// [[Rcpp::export]]
arma::mat smqrGaussInf(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h = 0.05, const double tau = 0.5,
const int B = 1000, const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
arma::mat rst(p + 1, B);
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
for (int b = 0; b < B; b++) {
arma::uvec idx = arma::find(arma::randi(n, arma::distr_param(0, 1)) == 1);
arma::mat mbX = X.rows(idx);
arma::mat mbY = Y.rows(idx);
rst.col(b) = smqrGaussIni(mbX, mbY, betaHat, p, tau, h, tol, iteMax, stepMax);
}
return rst;
}
// [[Rcpp::export]]
arma::mat smqrLogisticInf(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h = 0.05, const double tau = 0.5,
const int B = 1000, const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
arma::mat rst(p + 1, B);
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
for (int b = 0; b < B; b++) {
arma::uvec idx = arma::find(arma::randi(n, arma::distr_param(0, 1)) == 1);
arma::mat mbX = X.rows(idx);
arma::mat mbY = Y.rows(idx);
rst.col(b) = smqrLogisticIni(mbX, mbY, betaHat, p, tau, h, tol, iteMax, stepMax);
}
return rst;
}
// [[Rcpp::export]]
arma::mat smqrUnifInf(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h = 0.05, const double tau = 0.5,
const int B = 1000, const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
arma::mat rst(p + 1, B);
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
for (int b = 0; b < B; b++) {
arma::uvec idx = arma::find(arma::randi(n, arma::distr_param(0, 1)) == 1);
arma::mat mbX = X.rows(idx);
arma::mat mbY = Y.rows(idx);
rst.col(b) = smqrUnifIni(mbX, mbY, betaHat, p, tau, h, tol, iteMax, stepMax);
}
return rst;
}
// [[Rcpp::export]]
arma::mat smqrParaInf(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h = 0.05, const double tau = 0.5,
const int B = 1000, const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
arma::mat rst(p + 1, B);
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
for (int b = 0; b < B; b++) {
arma::uvec idx = arma::find(arma::randi(n, arma::distr_param(0, 1)) == 1);
arma::mat mbX = X.rows(idx);
arma::mat mbY = Y.rows(idx);
rst.col(b) = smqrParaIni(mbX, mbY, betaHat, p, tau, h, tol, iteMax, stepMax);
}
return rst;
}
// [[Rcpp::export]]
arma::mat smqrTrianInf(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h = 0.05, const double tau = 0.5,
const int B = 1000, const double tol = 0.0001, const int iteMax = 5000, const double stepMax = 100.0) {
arma::mat rst(p + 1, B);
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
for (int b = 0; b < B; b++) {
arma::uvec idx = arma::find(arma::randi(n, arma::distr_param(0, 1)) == 1);
arma::mat mbX = X.rows(idx);
arma::mat mbY = Y.rows(idx);
rst.col(b) = smqrTrianIni(mbX, mbY, betaHat, p, tau, h, tol, iteMax, stepMax);
}
return rst;
}
// Functions without an upper bound for the step size
// [[Rcpp::export]]
arma::vec huberRegUbd(const arma::mat& Z, const arma::vec& Y, const double tau, arma::vec& der, arma::vec& gradOld, arma::vec& gradNew, const int n, const int p,
const double n1, const double tol = 0.0001, const double constTau = 1.345, const int iteMax = 5000) {
double rob = constTau * mad(Y);
updateHuber(Z, Y, tau, der, gradOld, n, rob, n1);
arma::vec beta = -gradOld, betaDiff = -gradOld;
arma::vec res = Y - Z * beta;
rob = constTau * mad(res);
updateHuber(Z, res, tau, der, gradNew, n, rob, n1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
rob = constTau * mad(res);
updateHuber(Z, res, tau, der, gradNew, n, rob, n1);
gradDiff = gradNew - gradOld;
ite++;
}
return beta;
}
// Low-dimensional conquer: estimation
// [[Rcpp::export]]
Rcpp::List smqrGaussUbd(const arma::mat& X, arma::vec Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
const int p = X.n_cols;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateGauss(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrGaussNsdUbd(const arma::mat& Z, const arma::vec& Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = Z.n_rows;
const int p = Z.n_cols - 1;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateGauss(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
arma::vec smqrGaussIniUbd(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau = 0.5, double h = 0.05,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = betaHat;
arma::vec res = Y - Z * beta;
updateGauss(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return beta;
}
// [[Rcpp::export]]
Rcpp::List smqrLogisticUbd(const arma::mat& X, arma::vec Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
const int p = X.n_cols;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateLogistic(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrLogisticNsdUbd(const arma::mat& Z, const arma::vec& Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = Z.n_rows;
const int p = Z.n_cols - 1;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateLogistic(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
arma::vec smqrLogisticIniUbd(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau = 0.5, double h = 0.05,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = betaHat;
arma::vec res = Y - Z * beta;
updateLogistic(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return beta;
}
// [[Rcpp::export]]
Rcpp::List smqrUnifUbd(const arma::mat& X, arma::vec Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
const int p = X.n_cols;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateUnif(Z, res, der, gradOld, n, tau, h, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradNew, n, tau, h, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradNew, n, tau, h, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrUnifNsdUbd(const arma::mat& Z, const arma::vec& Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = Z.n_rows;
const int p = Z.n_cols - 1;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateUnif(Z, res, der, gradOld, n, tau, h, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradNew, n, tau, h, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradNew, n, tau, h, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
arma::vec smqrUnifIniUbd(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau = 0.5, double h = 0.05,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = betaHat;
arma::vec res = Y - Z * beta;
updateUnif(Z, res, der, gradOld, n, tau, h, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradNew, n, tau, h, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradNew, n, tau, h, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return beta;
}
// [[Rcpp::export]]
Rcpp::List smqrParaUbd(const arma::mat& X, arma::vec Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
const int p = X.n_cols;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updatePara(Z, res, der, gradOld, n, tau, h, n1, h1, h3);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updatePara(Z, res, der, gradNew, n, tau, h, n1, h1, h3);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updatePara(Z, res, der, gradNew, n, tau, h, n1, h1, h3);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrParaNsdUbd(const arma::mat& Z, const arma::vec& Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = Z.n_rows;
const int p = Z.n_cols - 1;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updatePara(Z, res, der, gradOld, n, tau, h, n1, h1, h3);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updatePara(Z, res, der, gradNew, n, tau, h, n1, h1, h3);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updatePara(Z, res, der, gradNew, n, tau, h, n1, h1, h3);
gradDiff = gradNew - gradOld;
ite++;
}
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
arma::vec smqrParaIniUbd(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau = 0.5, double h = 0.05,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = betaHat;
arma::vec res = Y - Z * beta;
updatePara(Z, res, der, gradOld, n, tau, h, n1, h1, h3);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updatePara(Z, res, der, gradNew, n, tau, h, n1, h1, h3);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updatePara(Z, res, der, gradNew, n, tau, h, n1, h1, h3);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return beta;
}
// [[Rcpp::export]]
Rcpp::List smqrTrianUbd(const arma::mat& X, arma::vec Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
const int p = X.n_cols;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateTrian(Z, res, der, gradOld, n, tau, h, n1, h1, h2);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradNew, n, tau, h, n1, h1, h2);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradNew, n, tau, h, n1, h1, h2);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrTrianNsdUbd(const arma::mat& Z, const arma::vec& Y, const double tau = 0.5, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = Z.n_rows;
const int p = Z.n_cols - 1;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateTrian(Z, res, der, gradOld, n, tau, h, n1, h1, h2);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradNew, n, tau, h, n1, h1, h2);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradNew, n, tau, h, n1, h1, h2);
gradDiff = gradNew - gradOld;
ite++;
}
return Rcpp::List::create(Rcpp::Named("coeff") = beta, Rcpp::Named("ite") = ite, Rcpp::Named("residual") = res, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
arma::vec smqrTrianIniUbd(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau = 0.5, double h = 0.05,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::vec beta = betaHat;
arma::vec res = Y - Z * beta;
updateTrian(Z, res, der, gradOld, n, tau, h, n1, h1, h2);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradNew, n, tau, h, n1, h1, h2);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradNew, n, tau, h, n1, h1, h2);
gradDiff = gradNew - gradOld;
ite++;
}
beta.rows(1, p) %= sx1;
beta(0) += my - arma::as_scalar(mx * beta.rows(1, p));
return beta;
}
// Global conquer process with a quantile grid
// [[Rcpp::export]]
Rcpp::List smqrGaussProcUbd(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
const int p = X.n_cols;
const int m = tauSeq.size();
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::mat betaProc(p + 1, m);
for (int i = 0; i < m; i++) {
double tau = tauSeq(i);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateGauss(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateGauss(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
betaProc.col(i) = beta;
}
betaProc.rows(1, p).each_col() %= sx1;
betaProc.row(0) += my - mx * betaProc.rows(1, p);
return Rcpp::List::create(Rcpp::Named("coeff") = betaProc, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrLogisticProcUbd(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
const int p = X.n_cols;
const int m = tauSeq.size();
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::mat betaProc(p + 1, m);
for (int i = 0; i < m; i++) {
double tau = tauSeq(i);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateLogistic(Z, res, der, gradOld, tau, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateLogistic(Z, res, der, gradNew, tau, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
betaProc.col(i) = beta;
}
betaProc.rows(1, p).each_col() %= sx1;
betaProc.row(0) += my - mx * betaProc.rows(1, p);
return Rcpp::List::create(Rcpp::Named("coeff") = betaProc, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrUnifProcUbd(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
const int p = X.n_cols;
const int m = tauSeq.size();
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h;
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::mat betaProc(p + 1, m);
for (int i = 0; i < m; i++) {
double tau = tauSeq(i);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateUnif(Z, res, der, gradOld, n, tau, h, n1, h1);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradOld, n, tau, h, n1, h1);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateUnif(Z, res, der, gradOld, n, tau, h, n1, h1);
gradDiff = gradNew - gradOld;
ite++;
}
betaProc.col(i) = beta;
}
betaProc.rows(1, p).each_col() %= sx1;
betaProc.row(0) += my - mx * betaProc.rows(1, p);
return Rcpp::List::create(Rcpp::Named("coeff") = betaProc, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrParaProcUbd(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
const int p = X.n_cols;
const int m = tauSeq.size();
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h3 = 1.0 / (h * h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::mat betaProc(p + 1, m);
for (int i = 0; i < m; i++) {
double tau = tauSeq(i);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updatePara(Z, res, der, gradOld, n, tau, h, n1, h1, h3);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updatePara(Z, res, der, gradOld, n, tau, h, n1, h1, h3);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updatePara(Z, res, der, gradOld, n, tau, h, n1, h1, h3);
gradDiff = gradNew - gradOld;
ite++;
}
betaProc.col(i) = beta;
}
betaProc.rows(1, p).each_col() %= sx1;
betaProc.row(0) += my - mx * betaProc.rows(1, p);
return Rcpp::List::create(Rcpp::Named("coeff") = betaProc, Rcpp::Named("bandwidth") = h);
}
// [[Rcpp::export]]
Rcpp::List smqrTrianProcUbd(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h = 0.05, const double constTau = 1.345,
const double tol = 0.0001, const int iteMax = 5000) {
const int n = X.n_rows;
const int p = X.n_cols;
const int m = tauSeq.size();
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
const double n1 = 1.0 / n;
const double h1 = 1.0 / h, h2 = 1.0 / (h * h);
arma::rowvec mx = arma::mean(X, 0);
arma::vec sx1 = 1.0 / arma::stddev(X, 0, 0).t();
arma::mat Z = arma::join_rows(arma::ones(n), standardize(X, mx, sx1, p));
double my = arma::mean(Y);
Y -= my;
arma::vec der(n);
arma::vec gradOld(p + 1), gradNew(p + 1);
arma::mat betaProc(p + 1, m);
for (int i = 0; i < m; i++) {
double tau = tauSeq(i);
arma::vec beta = huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax);
arma::vec quant = {tau};
beta(0) = arma::as_scalar(arma::quantile(Y - Z.cols(1, p) * beta.rows(1, p), quant));
arma::vec res = Y - Z * beta;
updateTrian(Z, res, der, gradOld, n, tau, h, n1, h1, h2);
beta -= gradOld;
arma::vec betaDiff = -gradOld;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradOld, n, tau, h, n1, h1, h2);
arma::vec gradDiff = gradNew - gradOld;
int ite = 1;
while (arma::norm(gradNew, "inf") > tol && ite <= iteMax) {
double alpha = 1.0;
double cross = arma::as_scalar(betaDiff.t() * gradDiff);
if (cross > 0) {
double a1 = cross / arma::as_scalar(gradDiff.t() * gradDiff);
double a2 = arma::as_scalar(betaDiff.t() * betaDiff) / cross;
alpha = std::min(a1, a2);
}
gradOld = gradNew;
betaDiff = -alpha * gradNew;
beta += betaDiff;
res -= Z * betaDiff;
updateTrian(Z, res, der, gradOld, n, tau, h, n1, h1, h2);
gradDiff = gradNew - gradOld;
ite++;
}
betaProc.col(i) = beta;
}
betaProc.rows(1, p).each_col() %= sx1;
betaProc.row(0) += my - mx * betaProc.rows(1, p);
return Rcpp::List::create(Rcpp::Named("coeff") = betaProc, Rcpp::Named("bandwidth") = h);
}
// Conquer with bootstrap inference
// [[Rcpp::export]]
arma::mat smqrGaussInfUbd(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h = 0.05, const double tau = 0.5,
const int B = 1000, const double tol = 0.0001, const int iteMax = 5000) {
arma::mat rst(p + 1, B);
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
for (int b = 0; b < B; b++) {
arma::uvec idx = arma::find(arma::randi(n, arma::distr_param(0, 1)) == 1);
arma::mat mbX = X.rows(idx);
arma::mat mbY = Y.rows(idx);
rst.col(b) = smqrGaussIniUbd(mbX, mbY, betaHat, p, tau, h, tol, iteMax);
}
return rst;
}
// [[Rcpp::export]]
arma::mat smqrLogisticInfUbd(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h = 0.05, const double tau = 0.5,
const int B = 1000, const double tol = 0.0001, const int iteMax = 5000) {
arma::mat rst(p + 1, B);
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
for (int b = 0; b < B; b++) {
arma::uvec idx = arma::find(arma::randi(n, arma::distr_param(0, 1)) == 1);
arma::mat mbX = X.rows(idx);
arma::mat mbY = Y.rows(idx);
rst.col(b) = smqrLogisticIniUbd(mbX, mbY, betaHat, p, tau, h, tol, iteMax);
}
return rst;
}
// [[Rcpp::export]]
arma::mat smqrUnifInfUbd(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h = 0.05, const double tau = 0.5,
const int B = 1000, const double tol = 0.0001, const int iteMax = 5000) {
arma::mat rst(p + 1, B);
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
for (int b = 0; b < B; b++) {
arma::uvec idx = arma::find(arma::randi(n, arma::distr_param(0, 1)) == 1);
arma::mat mbX = X.rows(idx);
arma::mat mbY = Y.rows(idx);
rst.col(b) = smqrUnifIniUbd(mbX, mbY, betaHat, p, tau, h, tol, iteMax);
}
return rst;
}
// [[Rcpp::export]]
arma::mat smqrParaInfUbd(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h = 0.05, const double tau = 0.5,
const int B = 1000, const double tol = 0.0001, const int iteMax = 5000) {
arma::mat rst(p + 1, B);
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
for (int b = 0; b < B; b++) {
arma::uvec idx = arma::find(arma::randi(n, arma::distr_param(0, 1)) == 1);
arma::mat mbX = X.rows(idx);
arma::mat mbY = Y.rows(idx);
rst.col(b) = smqrParaIniUbd(mbX, mbY, betaHat, p, tau, h, tol, iteMax);
}
return rst;
}
// [[Rcpp::export]]
arma::mat smqrTrianInfUbd(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h = 0.05, const double tau = 0.5,
const int B = 1000, const double tol = 0.0001, const int iteMax = 5000) {
arma::mat rst(p + 1, B);
if (h <= 0.0) {
h = std::max(std::pow((std::log(n) + p) / n, 0.4), 0.05);
}
for (int b = 0; b < B; b++) {
arma::uvec idx = arma::find(arma::randi(n, arma::distr_param(0, 1)) == 1);
arma::mat mbX = X.rows(idx);
arma::mat mbY = Y.rows(idx);
rst.col(b) = smqrTrianIniUbd(mbX, mbY, betaHat, p, tau, h, tol, iteMax);
}
return rst;
}
// Inference based on asymptotic distribution
// [[Rcpp::export]]
arma::mat asymptoticCI(const arma::mat& X, const arma::vec& res, const arma::vec& coeff, const double tau,
const int n, const double h, const double z) {
arma::mat Z = arma::join_rows(arma::ones(n), X);
arma::vec Wh = arma::square(arma::normcdf(-res / h) - tau);
arma::vec Wh2 = arma::normpdf(res / h) / h;
arma::mat temp = Z;
for (int i = 0; i < n; i++) {
temp.row(i) = Wh.row(i) * Z.row(i);
}
arma::mat Stau = temp.t() * Z;
for (int i = 0; i < n; i++) {
temp.row(i) = Wh2.row(i) * Z.row(i);
}
arma::mat Dh = temp.t() * Z;
arma::mat Dhinv = Dh.i();
arma::vec tm = z * arma::sqrt(arma::diagvec(Dhinv * Stau * Dhinv));
return arma::join_rows(coeff - tm, coeff + tm);
}
conquer/src/RcppExports.cpp 0000644 0001762 0000144 00001411642 14401303002 015506 0 ustar ligges users // Generated by using Rcpp::compileAttributes() -> do not edit by hand
// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393
#include
#include
using namespace Rcpp;
#ifdef RCPP_USE_GLOBAL_ROSTREAM
Rcpp::Rostream& Rcpp::Rcout = Rcpp::Rcpp_cout_get();
Rcpp::Rostream& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get();
#endif
// sgn
int sgn(const double x);
RcppExport SEXP _conquer_sgn(SEXP xSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const double >::type x(xSEXP);
rcpp_result_gen = Rcpp::wrap(sgn(x));
return rcpp_result_gen;
END_RCPP
}
// mad
double mad(const arma::vec& x);
RcppExport SEXP _conquer_mad(SEXP xSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::vec& >::type x(xSEXP);
rcpp_result_gen = Rcpp::wrap(mad(x));
return rcpp_result_gen;
END_RCPP
}
// standardize
arma::mat standardize(arma::mat X, const arma::rowvec& mx, const arma::vec& sx1, const int p);
RcppExport SEXP _conquer_standardize(SEXP XSEXP, SEXP mxSEXP, SEXP sx1SEXP, SEXP pSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< arma::mat >::type X(XSEXP);
Rcpp::traits::input_parameter< const arma::rowvec& >::type mx(mxSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type sx1(sx1SEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
rcpp_result_gen = Rcpp::wrap(standardize(X, mx, sx1, p));
return rcpp_result_gen;
END_RCPP
}
// softThresh
arma::vec softThresh(const arma::vec& x, const arma::vec& Lambda, const int p);
RcppExport SEXP _conquer_softThresh(SEXP xSEXP, SEXP LambdaSEXP, SEXP pSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::vec& >::type x(xSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
rcpp_result_gen = Rcpp::wrap(softThresh(x, Lambda, p));
return rcpp_result_gen;
END_RCPP
}
// lossQr
void lossQr(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const int i, arma::vec& dev, arma::vec& devsq);
RcppExport SEXP _conquer_lossQr(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP iSEXP, SEXP devSEXP, SEXP devsqSEXP) {
BEGIN_RCPP
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type i(iSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type dev(devSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type devsq(devsqSEXP);
lossQr(Z, Y, beta, tau, i, dev, devsq);
return R_NilValue;
END_RCPP
}
// cmptLambdaLasso
arma::vec cmptLambdaLasso(const double lambda, const int p);
RcppExport SEXP _conquer_cmptLambdaLasso(SEXP lambdaSEXP, SEXP pSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
rcpp_result_gen = Rcpp::wrap(cmptLambdaLasso(lambda, p));
return rcpp_result_gen;
END_RCPP
}
// lossL2
double lossL2(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double n1, const double tau);
RcppExport SEXP _conquer_lossL2(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP n1SEXP, SEXP tauSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
rcpp_result_gen = Rcpp::wrap(lossL2(Z, Y, beta, n1, tau));
return rcpp_result_gen;
END_RCPP
}
// updateL2
double updateL2(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double n1, const double tau);
RcppExport SEXP _conquer_updateL2(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP gradSEXP, SEXP n1SEXP, SEXP tauSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type grad(gradSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
rcpp_result_gen = Rcpp::wrap(updateL2(Z, Y, beta, grad, n1, tau));
return rcpp_result_gen;
END_RCPP
}
// lammL2
double lammL2(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi, const double gamma, const int p, const double n1);
RcppExport SEXP _conquer_lammL2(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP n1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
rcpp_result_gen = Rcpp::wrap(lammL2(Z, Y, Lambda, beta, tau, phi, gamma, p, n1));
return rcpp_result_gen;
END_RCPP
}
// lasso
arma::vec lasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_lasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(lasso(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cmptLambdaSCAD
arma::vec cmptLambdaSCAD(const arma::vec& beta, const double lambda, const int p, const double para);
RcppExport SEXP _conquer_cmptLambdaSCAD(SEXP betaSEXP, SEXP lambdaSEXP, SEXP pSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(cmptLambdaSCAD(beta, lambda, p, para));
return rcpp_result_gen;
END_RCPP
}
// cmptLambdaMCP
arma::vec cmptLambdaMCP(const arma::vec& beta, const double lambda, const int p, const double para);
RcppExport SEXP _conquer_cmptLambdaMCP(SEXP betaSEXP, SEXP lambdaSEXP, SEXP pSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(cmptLambdaMCP(beta, lambda, p, para));
return rcpp_result_gen;
END_RCPP
}
// lossGaussHd
double lossGaussHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const double h, const double h1, const double h2);
RcppExport SEXP _conquer_lossGaussHd(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
rcpp_result_gen = Rcpp::wrap(lossGaussHd(Z, Y, beta, tau, h, h1, h2));
return rcpp_result_gen;
END_RCPP
}
// updateGaussHd
double updateGaussHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double tau, const double n1, const double h, const double h1, const double h2);
RcppExport SEXP _conquer_updateGaussHd(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP gradSEXP, SEXP tauSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type grad(gradSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
rcpp_result_gen = Rcpp::wrap(updateGaussHd(Z, Y, beta, grad, tau, n1, h, h1, h2));
return rcpp_result_gen;
END_RCPP
}
// lammGaussLasso
double lammGaussLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi, const double gamma, const int p, const double h, const double n1, const double h1, const double h2);
RcppExport SEXP _conquer_lammGaussLasso(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
rcpp_result_gen = Rcpp::wrap(lammGaussLasso(Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1, h2));
return rcpp_result_gen;
END_RCPP
}
// lammGaussElastic
double lammGaussElastic(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double alpha, const double phi, const double gamma, const int p, const double h, const double n1, const double h1, const double h2);
RcppExport SEXP _conquer_lammGaussElastic(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
rcpp_result_gen = Rcpp::wrap(lammGaussElastic(Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1, h2));
return rcpp_result_gen;
END_RCPP
}
// lammGaussGroupLasso
double lammGaussGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, arma::vec& beta, const double tau, const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1, const double h1, const double h2);
RcppExport SEXP _conquer_lammGaussGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP GSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
rcpp_result_gen = Rcpp::wrap(lammGaussGroupLasso(Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2));
return rcpp_result_gen;
END_RCPP
}
// lammGaussSparseGroupLasso
double lammGaussSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, const double lambda, arma::vec& beta, const double tau, const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1, const double h1, const double h2);
RcppExport SEXP _conquer_lammGaussSparseGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP lambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP GSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
rcpp_result_gen = Rcpp::wrap(lammGaussSparseGroupLasso(Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2));
return rcpp_result_gen;
END_RCPP
}
// gaussLasso
arma::vec gaussLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_gaussLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(gaussLasso(Z, Y, lambda, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// gaussLassoWarm
arma::vec gaussLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_gaussLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(gaussLassoWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// gaussElastic
arma::vec gaussElastic(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const double alpha, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_gaussElastic(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(gaussElastic(Z, Y, lambda, tau, alpha, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// gaussElasticWarm
arma::vec gaussElasticWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const double alpha, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_gaussElasticWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(gaussElasticWarm(Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// gaussGroupLasso
arma::vec gaussGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_gaussGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(gaussGroupLasso(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// gaussGroupLassoWarm
arma::vec gaussGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_gaussGroupLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(gaussGroupLassoWarm(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// gaussSparseGroupLasso
arma::vec gaussSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_gaussSparseGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(gaussSparseGroupLasso(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// gaussSparseGroupLassoWarm
arma::vec gaussSparseGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_gaussSparseGroupLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(gaussSparseGroupLassoWarm(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// gaussScad
arma::vec gaussScad(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_gaussScad(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(gaussScad(Z, Y, lambda, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// gaussScadWarm
arma::vec gaussScadWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax, const double para);
RcppExport SEXP _conquer_gaussScadWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(gaussScadWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, para));
return rcpp_result_gen;
END_RCPP
}
// gaussMcp
arma::vec gaussMcp(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_gaussMcp(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(gaussMcp(Z, Y, lambda, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// gaussMcpWarm
arma::vec gaussMcpWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax, const double para);
RcppExport SEXP _conquer_gaussMcpWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(gaussMcpWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, para));
return rcpp_result_gen;
END_RCPP
}
// conquerGaussLasso
arma::vec conquerGaussLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerGaussLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerGaussLasso(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerGaussLassoSeq
arma::mat conquerGaussLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerGaussLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerGaussLassoSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerGaussElastic
arma::vec conquerGaussElastic(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double alpha, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerGaussElastic(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerGaussElastic(X, Y, lambda, tau, alpha, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerGaussElasticSeq
arma::mat conquerGaussElasticSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double alpha, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerGaussElasticSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerGaussElasticSeq(X, Y, lambdaSeq, tau, alpha, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerGaussGroupLasso
arma::vec conquerGaussGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerGaussGroupLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerGaussGroupLasso(X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerGaussGroupLassoSeq
arma::mat conquerGaussGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerGaussGroupLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerGaussGroupLassoSeq(X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerGaussSparseGroupLasso
arma::vec conquerGaussSparseGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerGaussSparseGroupLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerGaussSparseGroupLasso(X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerGaussSparseGroupLassoSeq
arma::mat conquerGaussSparseGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerGaussSparseGroupLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerGaussSparseGroupLassoSeq(X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerGaussScad
arma::vec conquerGaussScad(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerGaussScad(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerGaussScad(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerGaussScadSeq
arma::mat conquerGaussScadSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerGaussScadSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerGaussScadSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerGaussMcp
arma::vec conquerGaussMcp(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerGaussMcp(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerGaussMcp(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerGaussMcpSeq
arma::mat conquerGaussMcpSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerGaussMcpSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerGaussMcpSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// cvGaussLassoWarm
Rcpp::List cvGaussLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvGaussLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvGaussLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvGaussElasticWarm
Rcpp::List cvGaussElasticWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const double alpha, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvGaussElasticWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvGaussElasticWarm(X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvGaussGroupLassoWarm
Rcpp::List cvGaussGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvGaussGroupLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvGaussGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvGaussSparseGroupLassoWarm
Rcpp::List cvGaussSparseGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvGaussSparseGroupLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvGaussSparseGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvGaussScadWarm
Rcpp::List cvGaussScadWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_cvGaussScadWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(cvGaussScadWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// cvGaussMcpWarm
Rcpp::List cvGaussMcpWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_cvGaussMcpWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(cvGaussMcpWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// lossLogisticHd
double lossLogisticHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const double h, const double h1);
RcppExport SEXP _conquer_lossLogisticHd(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
rcpp_result_gen = Rcpp::wrap(lossLogisticHd(Z, Y, beta, tau, h, h1));
return rcpp_result_gen;
END_RCPP
}
// updateLogisticHd
double updateLogisticHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double tau, const double n1, const double h, const double h1);
RcppExport SEXP _conquer_updateLogisticHd(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP gradSEXP, SEXP tauSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type grad(gradSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
rcpp_result_gen = Rcpp::wrap(updateLogisticHd(Z, Y, beta, grad, tau, n1, h, h1));
return rcpp_result_gen;
END_RCPP
}
// lammLogisticLasso
double lammLogisticLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi, const double gamma, const int p, const double h, const double n1, const double h1);
RcppExport SEXP _conquer_lammLogisticLasso(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
rcpp_result_gen = Rcpp::wrap(lammLogisticLasso(Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1));
return rcpp_result_gen;
END_RCPP
}
// lammLogisticElastic
double lammLogisticElastic(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double alpha, const double phi, const double gamma, const int p, const double h, const double n1, const double h1);
RcppExport SEXP _conquer_lammLogisticElastic(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
rcpp_result_gen = Rcpp::wrap(lammLogisticElastic(Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1));
return rcpp_result_gen;
END_RCPP
}
// lammLogisticGroupLasso
double lammLogisticGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, arma::vec& beta, const double tau, const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1, const double h1);
RcppExport SEXP _conquer_lammLogisticGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP GSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
rcpp_result_gen = Rcpp::wrap(lammLogisticGroupLasso(Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1));
return rcpp_result_gen;
END_RCPP
}
// lammLogisticSparseGroupLasso
double lammLogisticSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, const double lambda, arma::vec& beta, const double tau, const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1, const double h1);
RcppExport SEXP _conquer_lammLogisticSparseGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP lambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP GSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
rcpp_result_gen = Rcpp::wrap(lammLogisticSparseGroupLasso(Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1));
return rcpp_result_gen;
END_RCPP
}
// logisticLasso
arma::vec logisticLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_logisticLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(logisticLasso(Z, Y, lambda, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// logisticLassoWarm
arma::vec logisticLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_logisticLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(logisticLassoWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// logisticElastic
arma::vec logisticElastic(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const double alpha, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_logisticElastic(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(logisticElastic(Z, Y, lambda, tau, alpha, p, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// logisticElasticWarm
arma::vec logisticElasticWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const double alpha, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_logisticElasticWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(logisticElasticWarm(Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// logisticGroupLasso
arma::vec logisticGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_logisticGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(logisticGroupLasso(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// logisticGroupLassoWarm
arma::vec logisticGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_logisticGroupLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(logisticGroupLassoWarm(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// logisticSparseGroupLasso
arma::vec logisticSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_logisticSparseGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(logisticSparseGroupLasso(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// logisticSparseGroupLassoWarm
arma::vec logisticSparseGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_logisticSparseGroupLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(logisticSparseGroupLassoWarm(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// logisticScad
arma::vec logisticScad(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_logisticScad(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(logisticScad(Z, Y, lambda, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// logisticScadWarm
arma::vec logisticScadWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax, const double para);
RcppExport SEXP _conquer_logisticScadWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(logisticScadWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, para));
return rcpp_result_gen;
END_RCPP
}
// logisticMcp
arma::vec logisticMcp(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_logisticMcp(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(logisticMcp(Z, Y, lambda, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// logisticMcpWarm
arma::vec logisticMcpWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax, const double para);
RcppExport SEXP _conquer_logisticMcpWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(logisticMcpWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, para));
return rcpp_result_gen;
END_RCPP
}
// conquerLogisticLasso
arma::vec conquerLogisticLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerLogisticLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerLogisticLasso(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerLogisticLassoSeq
arma::mat conquerLogisticLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerLogisticLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerLogisticLassoSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerLogisticElastic
arma::vec conquerLogisticElastic(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double alpha, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerLogisticElastic(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerLogisticElastic(X, Y, lambda, tau, alpha, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerLogisticElasticSeq
arma::mat conquerLogisticElasticSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double alpha, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerLogisticElasticSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerLogisticElasticSeq(X, Y, lambdaSeq, tau, alpha, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerLogisticGroupLasso
arma::vec conquerLogisticGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerLogisticGroupLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerLogisticGroupLasso(X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerLogisticGroupLassoSeq
arma::mat conquerLogisticGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerLogisticGroupLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerLogisticGroupLassoSeq(X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerLogisticSparseGroupLasso
arma::vec conquerLogisticSparseGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerLogisticSparseGroupLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerLogisticSparseGroupLasso(X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerLogisticSparseGroupLassoSeq
arma::mat conquerLogisticSparseGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerLogisticSparseGroupLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerLogisticSparseGroupLassoSeq(X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerLogisticScad
arma::vec conquerLogisticScad(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerLogisticScad(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerLogisticScad(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerLogisticScadSeq
arma::mat conquerLogisticScadSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerLogisticScadSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerLogisticScadSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerLogisticMcp
arma::vec conquerLogisticMcp(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerLogisticMcp(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerLogisticMcp(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerLogisticMcpSeq
arma::mat conquerLogisticMcpSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerLogisticMcpSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerLogisticMcpSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// cvLogisticLassoWarm
Rcpp::List cvLogisticLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvLogisticLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvLogisticLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvLogisticElasticWarm
Rcpp::List cvLogisticElasticWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const double alpha, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvLogisticElasticWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvLogisticElasticWarm(X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvLogisticGroupLassoWarm
Rcpp::List cvLogisticGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvLogisticGroupLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvLogisticGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvLogisticSparseGroupLassoWarm
Rcpp::List cvLogisticSparseGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvLogisticSparseGroupLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvLogisticSparseGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvLogisticScadWarm
Rcpp::List cvLogisticScadWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_cvLogisticScadWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(cvLogisticScadWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// cvLogisticMcpWarm
Rcpp::List cvLogisticMcpWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_cvLogisticMcpWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(cvLogisticMcpWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// lossParaHd
double lossParaHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const double h, const double h1, const double h3);
RcppExport SEXP _conquer_lossParaHd(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
rcpp_result_gen = Rcpp::wrap(lossParaHd(Z, Y, beta, tau, h, h1, h3));
return rcpp_result_gen;
END_RCPP
}
// updateParaHd
double updateParaHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double tau, const double n1, const double h, const double h1, const double h3);
RcppExport SEXP _conquer_updateParaHd(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP gradSEXP, SEXP tauSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type grad(gradSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
rcpp_result_gen = Rcpp::wrap(updateParaHd(Z, Y, beta, grad, tau, n1, h, h1, h3));
return rcpp_result_gen;
END_RCPP
}
// lammParaLasso
double lammParaLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi, const double gamma, const int p, const double h, const double n1, const double h1, const double h3);
RcppExport SEXP _conquer_lammParaLasso(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h3SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
rcpp_result_gen = Rcpp::wrap(lammParaLasso(Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1, h3));
return rcpp_result_gen;
END_RCPP
}
// lammParaElastic
double lammParaElastic(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double alpha, const double phi, const double gamma, const int p, const double h, const double n1, const double h1, const double h3);
RcppExport SEXP _conquer_lammParaElastic(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h3SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
rcpp_result_gen = Rcpp::wrap(lammParaElastic(Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1, h3));
return rcpp_result_gen;
END_RCPP
}
// lammParaGroupLasso
double lammParaGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, arma::vec& beta, const double tau, const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1, const double h1, const double h3);
RcppExport SEXP _conquer_lammParaGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP GSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h3SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
rcpp_result_gen = Rcpp::wrap(lammParaGroupLasso(Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h3));
return rcpp_result_gen;
END_RCPP
}
// lammParaSparseGroupLasso
double lammParaSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, const double lambda, arma::vec& beta, const double tau, const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1, const double h1, const double h3);
RcppExport SEXP _conquer_lammParaSparseGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP lambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP GSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h3SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
rcpp_result_gen = Rcpp::wrap(lammParaSparseGroupLasso(Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h3));
return rcpp_result_gen;
END_RCPP
}
// paraLasso
arma::vec paraLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double h3, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_paraLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(paraLasso(Z, Y, lambda, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// paraLassoWarm
arma::vec paraLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double h3, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_paraLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(paraLassoWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// paraElastic
arma::vec paraElastic(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const double alpha, const int p, const double n1, const double h, const double h1, const double h3, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_paraElastic(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(paraElastic(Z, Y, lambda, tau, alpha, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// paraElasticWarm
arma::vec paraElasticWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const double alpha, const int p, const double n1, const double h, const double h1, const double h3, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_paraElasticWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(paraElasticWarm(Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// paraGroupLasso
arma::vec paraGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h3, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_paraGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(paraGroupLasso(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h3, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// paraGroupLassoWarm
arma::vec paraGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h3, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_paraGroupLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(paraGroupLassoWarm(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h3, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// paraSparseGroupLasso
arma::vec paraSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h3, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_paraSparseGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(paraSparseGroupLasso(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h3, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// paraSparseGroupLassoWarm
arma::vec paraSparseGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h3, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_paraSparseGroupLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(paraSparseGroupLassoWarm(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h3, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// paraScad
arma::vec paraScad(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double h3, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_paraScad(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(paraScad(Z, Y, lambda, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// paraScadWarm
arma::vec paraScadWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double h3, const double phi0, const double gamma, const double epsilon, const int iteMax, const double para);
RcppExport SEXP _conquer_paraScadWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(paraScadWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax, para));
return rcpp_result_gen;
END_RCPP
}
// paraMcp
arma::vec paraMcp(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double h3, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_paraMcp(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(paraMcp(Z, Y, lambda, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// paraMcpWarm
arma::vec paraMcpWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double h3, const double phi0, const double gamma, const double epsilon, const int iteMax, const double para);
RcppExport SEXP _conquer_paraMcpWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h3SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(paraMcpWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax, para));
return rcpp_result_gen;
END_RCPP
}
// conquerParaLasso
arma::vec conquerParaLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerParaLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerParaLasso(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerParaLassoSeq
arma::mat conquerParaLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerParaLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerParaLassoSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerParaElastic
arma::vec conquerParaElastic(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double alpha, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerParaElastic(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerParaElastic(X, Y, lambda, tau, alpha, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerParaElasticSeq
arma::mat conquerParaElasticSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double alpha, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerParaElasticSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerParaElasticSeq(X, Y, lambdaSeq, tau, alpha, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerParaGroupLasso
arma::vec conquerParaGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerParaGroupLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerParaGroupLasso(X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerParaGroupLassoSeq
arma::mat conquerParaGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerParaGroupLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerParaGroupLassoSeq(X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerParaSparseGroupLasso
arma::vec conquerParaSparseGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerParaSparseGroupLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerParaSparseGroupLasso(X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerParaSparseGroupLassoSeq
arma::mat conquerParaSparseGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerParaSparseGroupLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerParaSparseGroupLassoSeq(X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerParaScad
arma::vec conquerParaScad(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerParaScad(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerParaScad(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerParaScadSeq
arma::mat conquerParaScadSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerParaScadSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerParaScadSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerParaMcp
arma::vec conquerParaMcp(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerParaMcp(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerParaMcp(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerParaMcpSeq
arma::mat conquerParaMcpSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerParaMcpSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerParaMcpSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// cvParaLassoWarm
Rcpp::List cvParaLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvParaLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvParaLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvParaElasticWarm
Rcpp::List cvParaElasticWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const double alpha, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvParaElasticWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvParaElasticWarm(X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvParaGroupLassoWarm
Rcpp::List cvParaGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvParaGroupLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvParaGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvParaSparseGroupLassoWarm
Rcpp::List cvParaSparseGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvParaSparseGroupLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvParaSparseGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvParaScadWarm
Rcpp::List cvParaScadWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_cvParaScadWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(cvParaScadWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// cvParaMcpWarm
Rcpp::List cvParaMcpWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_cvParaMcpWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(cvParaMcpWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// lossTrianHd
double lossTrianHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const double h, const double h1, const double h2);
RcppExport SEXP _conquer_lossTrianHd(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
rcpp_result_gen = Rcpp::wrap(lossTrianHd(Z, Y, beta, tau, h, h1, h2));
return rcpp_result_gen;
END_RCPP
}
// updateTrianHd
double updateTrianHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double tau, const double n1, const double h, const double h1, const double h2);
RcppExport SEXP _conquer_updateTrianHd(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP gradSEXP, SEXP tauSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type grad(gradSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
rcpp_result_gen = Rcpp::wrap(updateTrianHd(Z, Y, beta, grad, tau, n1, h, h1, h2));
return rcpp_result_gen;
END_RCPP
}
// lammTrianLasso
double lammTrianLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi, const double gamma, const int p, const double h, const double n1, const double h1, const double h2);
RcppExport SEXP _conquer_lammTrianLasso(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
rcpp_result_gen = Rcpp::wrap(lammTrianLasso(Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1, h2));
return rcpp_result_gen;
END_RCPP
}
// lammTrianElastic
double lammTrianElastic(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double alpha, const double phi, const double gamma, const int p, const double h, const double n1, const double h1, const double h2);
RcppExport SEXP _conquer_lammTrianElastic(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
rcpp_result_gen = Rcpp::wrap(lammTrianElastic(Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1, h2));
return rcpp_result_gen;
END_RCPP
}
// lammTrianGroupLasso
double lammTrianGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, arma::vec& beta, const double tau, const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1, const double h1, const double h2);
RcppExport SEXP _conquer_lammTrianGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP GSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
rcpp_result_gen = Rcpp::wrap(lammTrianGroupLasso(Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2));
return rcpp_result_gen;
END_RCPP
}
// lammTrianSparseGroupLasso
double lammTrianSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, const double lambda, arma::vec& beta, const double tau, const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1, const double h1, const double h2);
RcppExport SEXP _conquer_lammTrianSparseGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP lambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP GSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
rcpp_result_gen = Rcpp::wrap(lammTrianSparseGroupLasso(Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2));
return rcpp_result_gen;
END_RCPP
}
// trianLasso
arma::vec trianLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_trianLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(trianLasso(Z, Y, lambda, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// trianLassoWarm
arma::vec trianLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_trianLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(trianLassoWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// trianElastic
arma::vec trianElastic(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const double alpha, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_trianElastic(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(trianElastic(Z, Y, lambda, tau, alpha, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// trianElasticWarm
arma::vec trianElasticWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const double alpha, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_trianElasticWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(trianElasticWarm(Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// trianGroupLasso
arma::vec trianGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_trianGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(trianGroupLasso(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// trianGroupLassoWarm
arma::vec trianGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_trianGroupLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(trianGroupLassoWarm(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// trianSparseGroupLasso
arma::vec trianSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_trianSparseGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(trianSparseGroupLasso(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// trianSparseGroupLassoWarm
arma::vec trianSparseGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_trianSparseGroupLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(trianSparseGroupLassoWarm(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// trianScad
arma::vec trianScad(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_trianScad(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(trianScad(Z, Y, lambda, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// trianScadWarm
arma::vec trianScadWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax, const double para);
RcppExport SEXP _conquer_trianScadWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(trianScadWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, para));
return rcpp_result_gen;
END_RCPP
}
// trianMcp
arma::vec trianMcp(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_trianMcp(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(trianMcp(Z, Y, lambda, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// trianMcpWarm
arma::vec trianMcpWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double h2, const double phi0, const double gamma, const double epsilon, const int iteMax, const double para);
RcppExport SEXP _conquer_trianMcpWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP h2SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(trianMcpWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, para));
return rcpp_result_gen;
END_RCPP
}
// conquerTrianLasso
arma::vec conquerTrianLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerTrianLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerTrianLasso(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerTrianLassoSeq
arma::mat conquerTrianLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerTrianLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerTrianLassoSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerTrianElastic
arma::vec conquerTrianElastic(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double alpha, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerTrianElastic(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerTrianElastic(X, Y, lambda, tau, alpha, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerTrianElasticSeq
arma::mat conquerTrianElasticSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double alpha, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerTrianElasticSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerTrianElasticSeq(X, Y, lambdaSeq, tau, alpha, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerTrianGroupLasso
arma::vec conquerTrianGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerTrianGroupLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerTrianGroupLasso(X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerTrianGroupLassoSeq
arma::mat conquerTrianGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerTrianGroupLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerTrianGroupLassoSeq(X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerTrianSparseGroupLasso
arma::vec conquerTrianSparseGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerTrianSparseGroupLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerTrianSparseGroupLasso(X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerTrianSparseGroupLassoSeq
arma::mat conquerTrianSparseGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerTrianSparseGroupLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerTrianSparseGroupLassoSeq(X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerTrianScad
arma::vec conquerTrianScad(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerTrianScad(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerTrianScad(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerTrianScadSeq
arma::mat conquerTrianScadSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerTrianScadSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerTrianScadSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerTrianMcp
arma::vec conquerTrianMcp(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerTrianMcp(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerTrianMcp(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerTrianMcpSeq
arma::mat conquerTrianMcpSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerTrianMcpSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerTrianMcpSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// cvTrianLassoWarm
Rcpp::List cvTrianLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvTrianLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvTrianLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvTrianElasticWarm
Rcpp::List cvTrianElasticWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const double alpha, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvTrianElasticWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvTrianElasticWarm(X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvTrianGroupLassoWarm
Rcpp::List cvTrianGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvTrianGroupLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvTrianGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvTrianSparseGroupLassoWarm
Rcpp::List cvTrianSparseGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvTrianSparseGroupLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvTrianSparseGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvTrianScadWarm
Rcpp::List cvTrianScadWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_cvTrianScadWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(cvTrianScadWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// cvTrianMcpWarm
Rcpp::List cvTrianMcpWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_cvTrianMcpWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(cvTrianMcpWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// lossUnifHd
double lossUnifHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, const double tau, const double h, const double h1);
RcppExport SEXP _conquer_lossUnifHd(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
rcpp_result_gen = Rcpp::wrap(lossUnifHd(Z, Y, beta, tau, h, h1));
return rcpp_result_gen;
END_RCPP
}
// updateUnifHd
double updateUnifHd(const arma::mat& Z, const arma::vec& Y, const arma::vec& beta, arma::vec& grad, const double tau, const double n1, const double h, const double h1);
RcppExport SEXP _conquer_updateUnifHd(SEXP ZSEXP, SEXP YSEXP, SEXP betaSEXP, SEXP gradSEXP, SEXP tauSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type grad(gradSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
rcpp_result_gen = Rcpp::wrap(updateUnifHd(Z, Y, beta, grad, tau, n1, h, h1));
return rcpp_result_gen;
END_RCPP
}
// lammUnifLasso
double lammUnifLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double phi, const double gamma, const int p, const double h, const double n1, const double h1);
RcppExport SEXP _conquer_lammUnifLasso(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
rcpp_result_gen = Rcpp::wrap(lammUnifLasso(Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1));
return rcpp_result_gen;
END_RCPP
}
// lammUnifElastic
double lammUnifElastic(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, arma::vec& beta, const double tau, const double alpha, const double phi, const double gamma, const int p, const double h, const double n1, const double h1);
RcppExport SEXP _conquer_lammUnifElastic(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
rcpp_result_gen = Rcpp::wrap(lammUnifElastic(Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1));
return rcpp_result_gen;
END_RCPP
}
// lammUnifGroupLasso
double lammUnifGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, arma::vec& beta, const double tau, const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1, const double h1);
RcppExport SEXP _conquer_lammUnifGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP GSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
rcpp_result_gen = Rcpp::wrap(lammUnifGroupLasso(Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1));
return rcpp_result_gen;
END_RCPP
}
// lammUnifSparseGroupLasso
double lammUnifSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const arma::vec& Lambda, const double lambda, arma::vec& beta, const double tau, const arma::vec& group, const arma::vec& weight, const double phi, const double gamma, const int p, const int G, const double h, const double n1, const double h1);
RcppExport SEXP _conquer_lammUnifSparseGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP LambdaSEXP, SEXP lambdaSEXP, SEXP betaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP phiSEXP, SEXP gammaSEXP, SEXP pSEXP, SEXP GSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Lambda(LambdaSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type beta(betaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const double >::type phi(phiSEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
rcpp_result_gen = Rcpp::wrap(lammUnifSparseGroupLasso(Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1));
return rcpp_result_gen;
END_RCPP
}
// unifLasso
arma::vec unifLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_unifLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(unifLasso(Z, Y, lambda, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// unifLassoWarm
arma::vec unifLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_unifLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(unifLassoWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// unifElastic
arma::vec unifElastic(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const double alpha, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_unifElastic(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(unifElastic(Z, Y, lambda, tau, alpha, p, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// unifElasticWarm
arma::vec unifElasticWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const double alpha, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_unifElasticWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(unifElasticWarm(Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// unifGroupLasso
arma::vec unifGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_unifGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(unifGroupLasso(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// unifGroupLassoWarm
arma::vec unifGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_unifGroupLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(unifGroupLassoWarm(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// unifSparseGroupLasso
arma::vec unifSparseGroupLasso(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_unifSparseGroupLasso(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(unifSparseGroupLasso(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// unifSparseGroupLassoWarm
arma::vec unifSparseGroupLassoWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const arma::vec& group, const arma::vec& weight, const int p, const int G, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_unifSparseGroupLassoWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP pSEXP, SEXP GSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(unifSparseGroupLassoWarm(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// unifScad
arma::vec unifScad(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_unifScad(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(unifScad(Z, Y, lambda, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// unifScadWarm
arma::vec unifScadWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax, const double para);
RcppExport SEXP _conquer_unifScadWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(unifScadWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, para));
return rcpp_result_gen;
END_RCPP
}
// unifMcp
arma::vec unifMcp(const arma::mat& Z, const arma::vec& Y, const double lambda, const double tau, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_unifMcp(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(unifMcp(Z, Y, lambda, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// unifMcpWarm
arma::vec unifMcpWarm(const arma::mat& Z, const arma::vec& Y, const double lambda, const arma::vec& betaWarm, const double tau, const int p, const double n1, const double h, const double h1, const double phi0, const double gamma, const double epsilon, const int iteMax, const double para);
RcppExport SEXP _conquer_unifMcpWarm(SEXP ZSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP betaWarmSEXP, SEXP tauSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP hSEXP, SEXP h1SEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaWarm(betaWarmSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(unifMcpWarm(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, para));
return rcpp_result_gen;
END_RCPP
}
// conquerUnifLasso
arma::vec conquerUnifLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerUnifLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerUnifLasso(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerUnifLassoSeq
arma::mat conquerUnifLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerUnifLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerUnifLassoSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerUnifElastic
arma::vec conquerUnifElastic(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double alpha, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerUnifElastic(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerUnifElastic(X, Y, lambda, tau, alpha, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerUnifElasticSeq
arma::mat conquerUnifElasticSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double alpha, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerUnifElasticSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerUnifElasticSeq(X, Y, lambdaSeq, tau, alpha, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerUnifGroupLasso
arma::vec conquerUnifGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerUnifGroupLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerUnifGroupLasso(X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerUnifGroupLassoSeq
arma::mat conquerUnifGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerUnifGroupLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerUnifGroupLassoSeq(X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerUnifSparseGroupLasso
arma::vec conquerUnifSparseGroupLasso(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerUnifSparseGroupLasso(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerUnifSparseGroupLasso(X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerUnifSparseGroupLassoSeq
arma::mat conquerUnifSparseGroupLassoSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_conquerUnifSparseGroupLassoSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(conquerUnifSparseGroupLassoSeq(X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// conquerUnifScad
arma::vec conquerUnifScad(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerUnifScad(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerUnifScad(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerUnifScadSeq
arma::mat conquerUnifScadSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerUnifScadSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerUnifScadSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerUnifMcp
arma::vec conquerUnifMcp(const arma::mat& X, arma::vec Y, const double lambda, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerUnifMcp(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type lambda(lambdaSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerUnifMcp(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// conquerUnifMcpSeq
arma::mat conquerUnifMcpSeq(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const double tau, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_conquerUnifMcpSeq(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(conquerUnifMcpSeq(X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// cvUnifLassoWarm
Rcpp::List cvUnifLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvUnifLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvUnifLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvUnifElasticWarm
Rcpp::List cvUnifElasticWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const double alpha, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvUnifElasticWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP alphaSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type alpha(alphaSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvUnifElasticWarm(X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvUnifGroupLassoWarm
Rcpp::List cvUnifGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvUnifGroupLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvUnifGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvUnifSparseGroupLassoWarm
Rcpp::List cvUnifSparseGroupLassoWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const arma::vec& group, const arma::vec& weight, const int G, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax);
RcppExport SEXP _conquer_cvUnifSparseGroupLassoWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP groupSEXP, SEXP weightSEXP, SEXP GSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type group(groupSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type weight(weightSEXP);
Rcpp::traits::input_parameter< const int >::type G(GSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(cvUnifSparseGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax));
return rcpp_result_gen;
END_RCPP
}
// cvUnifScadWarm
Rcpp::List cvUnifScadWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_cvUnifScadWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(cvUnifScadWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// cvUnifMcpWarm
Rcpp::List cvUnifMcpWarm(const arma::mat& X, arma::vec Y, const arma::vec& lambdaSeq, const arma::vec& folds, const double tau, const int kfolds, const double h, const double phi0, const double gamma, const double epsilon, const int iteMax, const int iteTight, const double para);
RcppExport SEXP _conquer_cvUnifMcpWarm(SEXP XSEXP, SEXP YSEXP, SEXP lambdaSeqSEXP, SEXP foldsSEXP, SEXP tauSEXP, SEXP kfoldsSEXP, SEXP hSEXP, SEXP phi0SEXP, SEXP gammaSEXP, SEXP epsilonSEXP, SEXP iteMaxSEXP, SEXP iteTightSEXP, SEXP paraSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type lambdaSeq(lambdaSeqSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type folds(foldsSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type kfolds(kfoldsSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type phi0(phi0SEXP);
Rcpp::traits::input_parameter< const double >::type gamma(gammaSEXP);
Rcpp::traits::input_parameter< const double >::type epsilon(epsilonSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const int >::type iteTight(iteTightSEXP);
Rcpp::traits::input_parameter< const double >::type para(paraSEXP);
rcpp_result_gen = Rcpp::wrap(cvUnifMcpWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para));
return rcpp_result_gen;
END_RCPP
}
// updateHuber
void updateHuber(const arma::mat& Z, const arma::vec& res, const double tau, arma::vec& der, arma::vec& grad, const int n, const double rob, const double n1);
RcppExport SEXP _conquer_updateHuber(SEXP ZSEXP, SEXP resSEXP, SEXP tauSEXP, SEXP derSEXP, SEXP gradSEXP, SEXP nSEXP, SEXP robSEXP, SEXP n1SEXP) {
BEGIN_RCPP
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type res(resSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type der(derSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type grad(gradSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const double >::type rob(robSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
updateHuber(Z, res, tau, der, grad, n, rob, n1);
return R_NilValue;
END_RCPP
}
// updateGauss
void updateGauss(const arma::mat& Z, const arma::vec& res, arma::vec& der, arma::vec& grad, const double tau, const double n1, const double h1);
RcppExport SEXP _conquer_updateGauss(SEXP ZSEXP, SEXP resSEXP, SEXP derSEXP, SEXP gradSEXP, SEXP tauSEXP, SEXP n1SEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type res(resSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type der(derSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type grad(gradSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
updateGauss(Z, res, der, grad, tau, n1, h1);
return R_NilValue;
END_RCPP
}
// updateLogistic
void updateLogistic(const arma::mat& Z, const arma::vec& res, arma::vec& der, arma::vec& grad, const double tau, const double n1, const double h1);
RcppExport SEXP _conquer_updateLogistic(SEXP ZSEXP, SEXP resSEXP, SEXP derSEXP, SEXP gradSEXP, SEXP tauSEXP, SEXP n1SEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type res(resSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type der(derSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type grad(gradSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
updateLogistic(Z, res, der, grad, tau, n1, h1);
return R_NilValue;
END_RCPP
}
// updateUnif
void updateUnif(const arma::mat& Z, const arma::vec& res, arma::vec& der, arma::vec& grad, const int n, const double tau, const double h, const double n1, const double h1);
RcppExport SEXP _conquer_updateUnif(SEXP ZSEXP, SEXP resSEXP, SEXP derSEXP, SEXP gradSEXP, SEXP nSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP) {
BEGIN_RCPP
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type res(resSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type der(derSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type grad(gradSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
updateUnif(Z, res, der, grad, n, tau, h, n1, h1);
return R_NilValue;
END_RCPP
}
// updatePara
void updatePara(const arma::mat& Z, const arma::vec& res, arma::vec& der, arma::vec& grad, const int n, const double tau, const double h, const double n1, const double h1, const double h3);
RcppExport SEXP _conquer_updatePara(SEXP ZSEXP, SEXP resSEXP, SEXP derSEXP, SEXP gradSEXP, SEXP nSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h3SEXP) {
BEGIN_RCPP
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type res(resSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type der(derSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type grad(gradSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h3(h3SEXP);
updatePara(Z, res, der, grad, n, tau, h, n1, h1, h3);
return R_NilValue;
END_RCPP
}
// updateTrian
void updateTrian(const arma::mat& Z, const arma::vec& res, arma::vec& der, arma::vec& grad, const int n, const double tau, const double h, const double n1, const double h1, const double h2);
RcppExport SEXP _conquer_updateTrian(SEXP ZSEXP, SEXP resSEXP, SEXP derSEXP, SEXP gradSEXP, SEXP nSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP n1SEXP, SEXP h1SEXP, SEXP h2SEXP) {
BEGIN_RCPP
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type res(resSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type der(derSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type grad(gradSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type h1(h1SEXP);
Rcpp::traits::input_parameter< const double >::type h2(h2SEXP);
updateTrian(Z, res, der, grad, n, tau, h, n1, h1, h2);
return R_NilValue;
END_RCPP
}
// huberReg
arma::vec huberReg(const arma::mat& Z, const arma::vec& Y, const double tau, arma::vec& der, arma::vec& gradOld, arma::vec& gradNew, const int n, const int p, const double n1, const double tol, const double constTau, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_huberReg(SEXP ZSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP derSEXP, SEXP gradOldSEXP, SEXP gradNewSEXP, SEXP nSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP tolSEXP, SEXP constTauSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type der(derSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type gradOld(gradOldSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type gradNew(gradNewSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(huberReg(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrGauss
Rcpp::List smqrGauss(const arma::mat& X, arma::vec Y, const double tau, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrGauss(SEXP XSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrGauss(X, Y, tau, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrGaussNsd
Rcpp::List smqrGaussNsd(const arma::mat& Z, const arma::vec& Y, const double tau, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrGaussNsd(SEXP ZSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrGaussNsd(Z, Y, tau, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrGaussIni
arma::vec smqrGaussIni(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau, double h, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrGaussIni(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP pSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrGaussIni(X, Y, betaHat, p, tau, h, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrLogistic
Rcpp::List smqrLogistic(const arma::mat& X, arma::vec Y, const double tau, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrLogistic(SEXP XSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrLogistic(X, Y, tau, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrLogisticNsd
Rcpp::List smqrLogisticNsd(const arma::mat& Z, const arma::vec& Y, const double tau, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrLogisticNsd(SEXP ZSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrLogisticNsd(Z, Y, tau, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrLogisticIni
arma::vec smqrLogisticIni(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau, double h, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrLogisticIni(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP pSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrLogisticIni(X, Y, betaHat, p, tau, h, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrUnif
Rcpp::List smqrUnif(const arma::mat& X, arma::vec Y, const double tau, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrUnif(SEXP XSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrUnif(X, Y, tau, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrUnifNsd
Rcpp::List smqrUnifNsd(const arma::mat& Z, const arma::vec& Y, const double tau, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrUnifNsd(SEXP ZSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrUnifNsd(Z, Y, tau, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrUnifIni
arma::vec smqrUnifIni(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau, double h, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrUnifIni(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP pSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrUnifIni(X, Y, betaHat, p, tau, h, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrPara
Rcpp::List smqrPara(const arma::mat& X, arma::vec Y, const double tau, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrPara(SEXP XSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrPara(X, Y, tau, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrParaNsd
Rcpp::List smqrParaNsd(const arma::mat& Z, const arma::vec& Y, const double tau, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrParaNsd(SEXP ZSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrParaNsd(Z, Y, tau, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrParaIni
arma::vec smqrParaIni(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau, double h, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrParaIni(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP pSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrParaIni(X, Y, betaHat, p, tau, h, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrTrian
Rcpp::List smqrTrian(const arma::mat& X, arma::vec Y, const double tau, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrTrian(SEXP XSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrTrian(X, Y, tau, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrTrianNsd
Rcpp::List smqrTrianNsd(const arma::mat& Z, const arma::vec& Y, const double tau, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrTrianNsd(SEXP ZSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrTrianNsd(Z, Y, tau, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrTrianIni
arma::vec smqrTrianIni(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau, double h, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrTrianIni(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP pSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrTrianIni(X, Y, betaHat, p, tau, h, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrGaussProc
Rcpp::List smqrGaussProc(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrGaussProc(SEXP XSEXP, SEXP YSEXP, SEXP tauSeqSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec >::type tauSeq(tauSeqSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrGaussProc(X, Y, tauSeq, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrLogisticProc
Rcpp::List smqrLogisticProc(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrLogisticProc(SEXP XSEXP, SEXP YSEXP, SEXP tauSeqSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec >::type tauSeq(tauSeqSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrLogisticProc(X, Y, tauSeq, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrUnifProc
Rcpp::List smqrUnifProc(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrUnifProc(SEXP XSEXP, SEXP YSEXP, SEXP tauSeqSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec >::type tauSeq(tauSeqSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrUnifProc(X, Y, tauSeq, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrParaProc
Rcpp::List smqrParaProc(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrParaProc(SEXP XSEXP, SEXP YSEXP, SEXP tauSeqSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec >::type tauSeq(tauSeqSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrParaProc(X, Y, tauSeq, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrTrianProc
Rcpp::List smqrTrianProc(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h, const double constTau, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrTrianProc(SEXP XSEXP, SEXP YSEXP, SEXP tauSeqSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec >::type tauSeq(tauSeqSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrTrianProc(X, Y, tauSeq, h, constTau, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrGaussInf
arma::mat smqrGaussInf(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h, const double tau, const int B, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrGaussInf(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP nSEXP, SEXP pSEXP, SEXP hSEXP, SEXP tauSEXP, SEXP BSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type B(BSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrGaussInf(X, Y, betaHat, n, p, h, tau, B, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrLogisticInf
arma::mat smqrLogisticInf(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h, const double tau, const int B, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrLogisticInf(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP nSEXP, SEXP pSEXP, SEXP hSEXP, SEXP tauSEXP, SEXP BSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type B(BSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrLogisticInf(X, Y, betaHat, n, p, h, tau, B, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrUnifInf
arma::mat smqrUnifInf(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h, const double tau, const int B, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrUnifInf(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP nSEXP, SEXP pSEXP, SEXP hSEXP, SEXP tauSEXP, SEXP BSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type B(BSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrUnifInf(X, Y, betaHat, n, p, h, tau, B, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrParaInf
arma::mat smqrParaInf(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h, const double tau, const int B, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrParaInf(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP nSEXP, SEXP pSEXP, SEXP hSEXP, SEXP tauSEXP, SEXP BSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type B(BSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrParaInf(X, Y, betaHat, n, p, h, tau, B, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// smqrTrianInf
arma::mat smqrTrianInf(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h, const double tau, const int B, const double tol, const int iteMax, const double stepMax);
RcppExport SEXP _conquer_smqrTrianInf(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP nSEXP, SEXP pSEXP, SEXP hSEXP, SEXP tauSEXP, SEXP BSEXP, SEXP tolSEXP, SEXP iteMaxSEXP, SEXP stepMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type B(BSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
Rcpp::traits::input_parameter< const double >::type stepMax(stepMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrTrianInf(X, Y, betaHat, n, p, h, tau, B, tol, iteMax, stepMax));
return rcpp_result_gen;
END_RCPP
}
// huberRegUbd
arma::vec huberRegUbd(const arma::mat& Z, const arma::vec& Y, const double tau, arma::vec& der, arma::vec& gradOld, arma::vec& gradNew, const int n, const int p, const double n1, const double tol, const double constTau, const int iteMax);
RcppExport SEXP _conquer_huberRegUbd(SEXP ZSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP derSEXP, SEXP gradOldSEXP, SEXP gradNewSEXP, SEXP nSEXP, SEXP pSEXP, SEXP n1SEXP, SEXP tolSEXP, SEXP constTauSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type der(derSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type gradOld(gradOldSEXP);
Rcpp::traits::input_parameter< arma::vec& >::type gradNew(gradNewSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type n1(n1SEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(huberRegUbd(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrGaussUbd
Rcpp::List smqrGaussUbd(const arma::mat& X, arma::vec Y, const double tau, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrGaussUbd(SEXP XSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrGaussUbd(X, Y, tau, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrGaussNsdUbd
Rcpp::List smqrGaussNsdUbd(const arma::mat& Z, const arma::vec& Y, const double tau, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrGaussNsdUbd(SEXP ZSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrGaussNsdUbd(Z, Y, tau, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrGaussIniUbd
arma::vec smqrGaussIniUbd(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau, double h, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrGaussIniUbd(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP pSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrGaussIniUbd(X, Y, betaHat, p, tau, h, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrLogisticUbd
Rcpp::List smqrLogisticUbd(const arma::mat& X, arma::vec Y, const double tau, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrLogisticUbd(SEXP XSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrLogisticUbd(X, Y, tau, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrLogisticNsdUbd
Rcpp::List smqrLogisticNsdUbd(const arma::mat& Z, const arma::vec& Y, const double tau, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrLogisticNsdUbd(SEXP ZSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrLogisticNsdUbd(Z, Y, tau, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrLogisticIniUbd
arma::vec smqrLogisticIniUbd(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau, double h, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrLogisticIniUbd(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP pSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrLogisticIniUbd(X, Y, betaHat, p, tau, h, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrUnifUbd
Rcpp::List smqrUnifUbd(const arma::mat& X, arma::vec Y, const double tau, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrUnifUbd(SEXP XSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrUnifUbd(X, Y, tau, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrUnifNsdUbd
Rcpp::List smqrUnifNsdUbd(const arma::mat& Z, const arma::vec& Y, const double tau, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrUnifNsdUbd(SEXP ZSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrUnifNsdUbd(Z, Y, tau, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrUnifIniUbd
arma::vec smqrUnifIniUbd(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau, double h, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrUnifIniUbd(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP pSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrUnifIniUbd(X, Y, betaHat, p, tau, h, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrParaUbd
Rcpp::List smqrParaUbd(const arma::mat& X, arma::vec Y, const double tau, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrParaUbd(SEXP XSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrParaUbd(X, Y, tau, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrParaNsdUbd
Rcpp::List smqrParaNsdUbd(const arma::mat& Z, const arma::vec& Y, const double tau, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrParaNsdUbd(SEXP ZSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrParaNsdUbd(Z, Y, tau, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrParaIniUbd
arma::vec smqrParaIniUbd(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau, double h, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrParaIniUbd(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP pSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrParaIniUbd(X, Y, betaHat, p, tau, h, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrTrianUbd
Rcpp::List smqrTrianUbd(const arma::mat& X, arma::vec Y, const double tau, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrTrianUbd(SEXP XSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrTrianUbd(X, Y, tau, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrTrianNsdUbd
Rcpp::List smqrTrianNsdUbd(const arma::mat& Z, const arma::vec& Y, const double tau, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrTrianNsdUbd(SEXP ZSEXP, SEXP YSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type Z(ZSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrTrianNsdUbd(Z, Y, tau, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrTrianIniUbd
arma::vec smqrTrianIniUbd(const arma::mat& X, arma::vec Y, const arma::vec& betaHat, const int p, const double tau, double h, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrTrianIniUbd(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP pSEXP, SEXP tauSEXP, SEXP hSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrTrianIniUbd(X, Y, betaHat, p, tau, h, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrGaussProcUbd
Rcpp::List smqrGaussProcUbd(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrGaussProcUbd(SEXP XSEXP, SEXP YSEXP, SEXP tauSeqSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec >::type tauSeq(tauSeqSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrGaussProcUbd(X, Y, tauSeq, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrLogisticProcUbd
Rcpp::List smqrLogisticProcUbd(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrLogisticProcUbd(SEXP XSEXP, SEXP YSEXP, SEXP tauSeqSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec >::type tauSeq(tauSeqSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrLogisticProcUbd(X, Y, tauSeq, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrUnifProcUbd
Rcpp::List smqrUnifProcUbd(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrUnifProcUbd(SEXP XSEXP, SEXP YSEXP, SEXP tauSeqSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec >::type tauSeq(tauSeqSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrUnifProcUbd(X, Y, tauSeq, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrParaProcUbd
Rcpp::List smqrParaProcUbd(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrParaProcUbd(SEXP XSEXP, SEXP YSEXP, SEXP tauSeqSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec >::type tauSeq(tauSeqSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrParaProcUbd(X, Y, tauSeq, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrTrianProcUbd
Rcpp::List smqrTrianProcUbd(const arma::mat& X, arma::vec Y, const arma::vec tauSeq, double h, const double constTau, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrTrianProcUbd(SEXP XSEXP, SEXP YSEXP, SEXP tauSeqSEXP, SEXP hSEXP, SEXP constTauSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< arma::vec >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec >::type tauSeq(tauSeqSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type constTau(constTauSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrTrianProcUbd(X, Y, tauSeq, h, constTau, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrGaussInfUbd
arma::mat smqrGaussInfUbd(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h, const double tau, const int B, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrGaussInfUbd(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP nSEXP, SEXP pSEXP, SEXP hSEXP, SEXP tauSEXP, SEXP BSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type B(BSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrGaussInfUbd(X, Y, betaHat, n, p, h, tau, B, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrLogisticInfUbd
arma::mat smqrLogisticInfUbd(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h, const double tau, const int B, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrLogisticInfUbd(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP nSEXP, SEXP pSEXP, SEXP hSEXP, SEXP tauSEXP, SEXP BSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type B(BSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrLogisticInfUbd(X, Y, betaHat, n, p, h, tau, B, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrUnifInfUbd
arma::mat smqrUnifInfUbd(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h, const double tau, const int B, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrUnifInfUbd(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP nSEXP, SEXP pSEXP, SEXP hSEXP, SEXP tauSEXP, SEXP BSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type B(BSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrUnifInfUbd(X, Y, betaHat, n, p, h, tau, B, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrParaInfUbd
arma::mat smqrParaInfUbd(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h, const double tau, const int B, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrParaInfUbd(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP nSEXP, SEXP pSEXP, SEXP hSEXP, SEXP tauSEXP, SEXP BSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type B(BSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrParaInfUbd(X, Y, betaHat, n, p, h, tau, B, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// smqrTrianInfUbd
arma::mat smqrTrianInfUbd(const arma::mat& X, const arma::vec& Y, const arma::vec& betaHat, const int n, const int p, double h, const double tau, const int B, const double tol, const int iteMax);
RcppExport SEXP _conquer_smqrTrianInfUbd(SEXP XSEXP, SEXP YSEXP, SEXP betaHatSEXP, SEXP nSEXP, SEXP pSEXP, SEXP hSEXP, SEXP tauSEXP, SEXP BSEXP, SEXP tolSEXP, SEXP iteMaxSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type Y(YSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type betaHat(betaHatSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const int >::type p(pSEXP);
Rcpp::traits::input_parameter< double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type B(BSEXP);
Rcpp::traits::input_parameter< const double >::type tol(tolSEXP);
Rcpp::traits::input_parameter< const int >::type iteMax(iteMaxSEXP);
rcpp_result_gen = Rcpp::wrap(smqrTrianInfUbd(X, Y, betaHat, n, p, h, tau, B, tol, iteMax));
return rcpp_result_gen;
END_RCPP
}
// asymptoticCI
arma::mat asymptoticCI(const arma::mat& X, const arma::vec& res, const arma::vec& coeff, const double tau, const int n, const double h, const double z);
RcppExport SEXP _conquer_asymptoticCI(SEXP XSEXP, SEXP resSEXP, SEXP coeffSEXP, SEXP tauSEXP, SEXP nSEXP, SEXP hSEXP, SEXP zSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type res(resSEXP);
Rcpp::traits::input_parameter< const arma::vec& >::type coeff(coeffSEXP);
Rcpp::traits::input_parameter< const double >::type tau(tauSEXP);
Rcpp::traits::input_parameter< const int >::type n(nSEXP);
Rcpp::traits::input_parameter< const double >::type h(hSEXP);
Rcpp::traits::input_parameter< const double >::type z(zSEXP);
rcpp_result_gen = Rcpp::wrap(asymptoticCI(X, res, coeff, tau, n, h, z));
return rcpp_result_gen;
END_RCPP
}
static const R_CallMethodDef CallEntries[] = {
{"_conquer_sgn", (DL_FUNC) &_conquer_sgn, 1},
{"_conquer_mad", (DL_FUNC) &_conquer_mad, 1},
{"_conquer_standardize", (DL_FUNC) &_conquer_standardize, 4},
{"_conquer_softThresh", (DL_FUNC) &_conquer_softThresh, 3},
{"_conquer_lossQr", (DL_FUNC) &_conquer_lossQr, 7},
{"_conquer_cmptLambdaLasso", (DL_FUNC) &_conquer_cmptLambdaLasso, 2},
{"_conquer_lossL2", (DL_FUNC) &_conquer_lossL2, 5},
{"_conquer_updateL2", (DL_FUNC) &_conquer_updateL2, 6},
{"_conquer_lammL2", (DL_FUNC) &_conquer_lammL2, 9},
{"_conquer_lasso", (DL_FUNC) &_conquer_lasso, 10},
{"_conquer_cmptLambdaSCAD", (DL_FUNC) &_conquer_cmptLambdaSCAD, 4},
{"_conquer_cmptLambdaMCP", (DL_FUNC) &_conquer_cmptLambdaMCP, 4},
{"_conquer_lossGaussHd", (DL_FUNC) &_conquer_lossGaussHd, 7},
{"_conquer_updateGaussHd", (DL_FUNC) &_conquer_updateGaussHd, 9},
{"_conquer_lammGaussLasso", (DL_FUNC) &_conquer_lammGaussLasso, 12},
{"_conquer_lammGaussElastic", (DL_FUNC) &_conquer_lammGaussElastic, 13},
{"_conquer_lammGaussGroupLasso", (DL_FUNC) &_conquer_lammGaussGroupLasso, 15},
{"_conquer_lammGaussSparseGroupLasso", (DL_FUNC) &_conquer_lammGaussSparseGroupLasso, 16},
{"_conquer_gaussLasso", (DL_FUNC) &_conquer_gaussLasso, 13},
{"_conquer_gaussLassoWarm", (DL_FUNC) &_conquer_gaussLassoWarm, 14},
{"_conquer_gaussElastic", (DL_FUNC) &_conquer_gaussElastic, 14},
{"_conquer_gaussElasticWarm", (DL_FUNC) &_conquer_gaussElasticWarm, 15},
{"_conquer_gaussGroupLasso", (DL_FUNC) &_conquer_gaussGroupLasso, 16},
{"_conquer_gaussGroupLassoWarm", (DL_FUNC) &_conquer_gaussGroupLassoWarm, 17},
{"_conquer_gaussSparseGroupLasso", (DL_FUNC) &_conquer_gaussSparseGroupLasso, 16},
{"_conquer_gaussSparseGroupLassoWarm", (DL_FUNC) &_conquer_gaussSparseGroupLassoWarm, 17},
{"_conquer_gaussScad", (DL_FUNC) &_conquer_gaussScad, 15},
{"_conquer_gaussScadWarm", (DL_FUNC) &_conquer_gaussScadWarm, 15},
{"_conquer_gaussMcp", (DL_FUNC) &_conquer_gaussMcp, 15},
{"_conquer_gaussMcpWarm", (DL_FUNC) &_conquer_gaussMcpWarm, 15},
{"_conquer_conquerGaussLasso", (DL_FUNC) &_conquer_conquerGaussLasso, 9},
{"_conquer_conquerGaussLassoSeq", (DL_FUNC) &_conquer_conquerGaussLassoSeq, 9},
{"_conquer_conquerGaussElastic", (DL_FUNC) &_conquer_conquerGaussElastic, 10},
{"_conquer_conquerGaussElasticSeq", (DL_FUNC) &_conquer_conquerGaussElasticSeq, 10},
{"_conquer_conquerGaussGroupLasso", (DL_FUNC) &_conquer_conquerGaussGroupLasso, 12},
{"_conquer_conquerGaussGroupLassoSeq", (DL_FUNC) &_conquer_conquerGaussGroupLassoSeq, 12},
{"_conquer_conquerGaussSparseGroupLasso", (DL_FUNC) &_conquer_conquerGaussSparseGroupLasso, 12},
{"_conquer_conquerGaussSparseGroupLassoSeq", (DL_FUNC) &_conquer_conquerGaussSparseGroupLassoSeq, 12},
{"_conquer_conquerGaussScad", (DL_FUNC) &_conquer_conquerGaussScad, 11},
{"_conquer_conquerGaussScadSeq", (DL_FUNC) &_conquer_conquerGaussScadSeq, 11},
{"_conquer_conquerGaussMcp", (DL_FUNC) &_conquer_conquerGaussMcp, 11},
{"_conquer_conquerGaussMcpSeq", (DL_FUNC) &_conquer_conquerGaussMcpSeq, 11},
{"_conquer_cvGaussLassoWarm", (DL_FUNC) &_conquer_cvGaussLassoWarm, 11},
{"_conquer_cvGaussElasticWarm", (DL_FUNC) &_conquer_cvGaussElasticWarm, 12},
{"_conquer_cvGaussGroupLassoWarm", (DL_FUNC) &_conquer_cvGaussGroupLassoWarm, 14},
{"_conquer_cvGaussSparseGroupLassoWarm", (DL_FUNC) &_conquer_cvGaussSparseGroupLassoWarm, 14},
{"_conquer_cvGaussScadWarm", (DL_FUNC) &_conquer_cvGaussScadWarm, 13},
{"_conquer_cvGaussMcpWarm", (DL_FUNC) &_conquer_cvGaussMcpWarm, 13},
{"_conquer_lossLogisticHd", (DL_FUNC) &_conquer_lossLogisticHd, 6},
{"_conquer_updateLogisticHd", (DL_FUNC) &_conquer_updateLogisticHd, 8},
{"_conquer_lammLogisticLasso", (DL_FUNC) &_conquer_lammLogisticLasso, 11},
{"_conquer_lammLogisticElastic", (DL_FUNC) &_conquer_lammLogisticElastic, 12},
{"_conquer_lammLogisticGroupLasso", (DL_FUNC) &_conquer_lammLogisticGroupLasso, 14},
{"_conquer_lammLogisticSparseGroupLasso", (DL_FUNC) &_conquer_lammLogisticSparseGroupLasso, 15},
{"_conquer_logisticLasso", (DL_FUNC) &_conquer_logisticLasso, 12},
{"_conquer_logisticLassoWarm", (DL_FUNC) &_conquer_logisticLassoWarm, 13},
{"_conquer_logisticElastic", (DL_FUNC) &_conquer_logisticElastic, 13},
{"_conquer_logisticElasticWarm", (DL_FUNC) &_conquer_logisticElasticWarm, 14},
{"_conquer_logisticGroupLasso", (DL_FUNC) &_conquer_logisticGroupLasso, 15},
{"_conquer_logisticGroupLassoWarm", (DL_FUNC) &_conquer_logisticGroupLassoWarm, 16},
{"_conquer_logisticSparseGroupLasso", (DL_FUNC) &_conquer_logisticSparseGroupLasso, 15},
{"_conquer_logisticSparseGroupLassoWarm", (DL_FUNC) &_conquer_logisticSparseGroupLassoWarm, 16},
{"_conquer_logisticScad", (DL_FUNC) &_conquer_logisticScad, 14},
{"_conquer_logisticScadWarm", (DL_FUNC) &_conquer_logisticScadWarm, 14},
{"_conquer_logisticMcp", (DL_FUNC) &_conquer_logisticMcp, 14},
{"_conquer_logisticMcpWarm", (DL_FUNC) &_conquer_logisticMcpWarm, 14},
{"_conquer_conquerLogisticLasso", (DL_FUNC) &_conquer_conquerLogisticLasso, 9},
{"_conquer_conquerLogisticLassoSeq", (DL_FUNC) &_conquer_conquerLogisticLassoSeq, 9},
{"_conquer_conquerLogisticElastic", (DL_FUNC) &_conquer_conquerLogisticElastic, 10},
{"_conquer_conquerLogisticElasticSeq", (DL_FUNC) &_conquer_conquerLogisticElasticSeq, 10},
{"_conquer_conquerLogisticGroupLasso", (DL_FUNC) &_conquer_conquerLogisticGroupLasso, 12},
{"_conquer_conquerLogisticGroupLassoSeq", (DL_FUNC) &_conquer_conquerLogisticGroupLassoSeq, 12},
{"_conquer_conquerLogisticSparseGroupLasso", (DL_FUNC) &_conquer_conquerLogisticSparseGroupLasso, 12},
{"_conquer_conquerLogisticSparseGroupLassoSeq", (DL_FUNC) &_conquer_conquerLogisticSparseGroupLassoSeq, 12},
{"_conquer_conquerLogisticScad", (DL_FUNC) &_conquer_conquerLogisticScad, 11},
{"_conquer_conquerLogisticScadSeq", (DL_FUNC) &_conquer_conquerLogisticScadSeq, 11},
{"_conquer_conquerLogisticMcp", (DL_FUNC) &_conquer_conquerLogisticMcp, 11},
{"_conquer_conquerLogisticMcpSeq", (DL_FUNC) &_conquer_conquerLogisticMcpSeq, 11},
{"_conquer_cvLogisticLassoWarm", (DL_FUNC) &_conquer_cvLogisticLassoWarm, 11},
{"_conquer_cvLogisticElasticWarm", (DL_FUNC) &_conquer_cvLogisticElasticWarm, 12},
{"_conquer_cvLogisticGroupLassoWarm", (DL_FUNC) &_conquer_cvLogisticGroupLassoWarm, 14},
{"_conquer_cvLogisticSparseGroupLassoWarm", (DL_FUNC) &_conquer_cvLogisticSparseGroupLassoWarm, 14},
{"_conquer_cvLogisticScadWarm", (DL_FUNC) &_conquer_cvLogisticScadWarm, 13},
{"_conquer_cvLogisticMcpWarm", (DL_FUNC) &_conquer_cvLogisticMcpWarm, 13},
{"_conquer_lossParaHd", (DL_FUNC) &_conquer_lossParaHd, 7},
{"_conquer_updateParaHd", (DL_FUNC) &_conquer_updateParaHd, 9},
{"_conquer_lammParaLasso", (DL_FUNC) &_conquer_lammParaLasso, 12},
{"_conquer_lammParaElastic", (DL_FUNC) &_conquer_lammParaElastic, 13},
{"_conquer_lammParaGroupLasso", (DL_FUNC) &_conquer_lammParaGroupLasso, 15},
{"_conquer_lammParaSparseGroupLasso", (DL_FUNC) &_conquer_lammParaSparseGroupLasso, 16},
{"_conquer_paraLasso", (DL_FUNC) &_conquer_paraLasso, 13},
{"_conquer_paraLassoWarm", (DL_FUNC) &_conquer_paraLassoWarm, 14},
{"_conquer_paraElastic", (DL_FUNC) &_conquer_paraElastic, 14},
{"_conquer_paraElasticWarm", (DL_FUNC) &_conquer_paraElasticWarm, 15},
{"_conquer_paraGroupLasso", (DL_FUNC) &_conquer_paraGroupLasso, 16},
{"_conquer_paraGroupLassoWarm", (DL_FUNC) &_conquer_paraGroupLassoWarm, 17},
{"_conquer_paraSparseGroupLasso", (DL_FUNC) &_conquer_paraSparseGroupLasso, 16},
{"_conquer_paraSparseGroupLassoWarm", (DL_FUNC) &_conquer_paraSparseGroupLassoWarm, 17},
{"_conquer_paraScad", (DL_FUNC) &_conquer_paraScad, 15},
{"_conquer_paraScadWarm", (DL_FUNC) &_conquer_paraScadWarm, 15},
{"_conquer_paraMcp", (DL_FUNC) &_conquer_paraMcp, 15},
{"_conquer_paraMcpWarm", (DL_FUNC) &_conquer_paraMcpWarm, 15},
{"_conquer_conquerParaLasso", (DL_FUNC) &_conquer_conquerParaLasso, 9},
{"_conquer_conquerParaLassoSeq", (DL_FUNC) &_conquer_conquerParaLassoSeq, 9},
{"_conquer_conquerParaElastic", (DL_FUNC) &_conquer_conquerParaElastic, 10},
{"_conquer_conquerParaElasticSeq", (DL_FUNC) &_conquer_conquerParaElasticSeq, 10},
{"_conquer_conquerParaGroupLasso", (DL_FUNC) &_conquer_conquerParaGroupLasso, 12},
{"_conquer_conquerParaGroupLassoSeq", (DL_FUNC) &_conquer_conquerParaGroupLassoSeq, 12},
{"_conquer_conquerParaSparseGroupLasso", (DL_FUNC) &_conquer_conquerParaSparseGroupLasso, 12},
{"_conquer_conquerParaSparseGroupLassoSeq", (DL_FUNC) &_conquer_conquerParaSparseGroupLassoSeq, 12},
{"_conquer_conquerParaScad", (DL_FUNC) &_conquer_conquerParaScad, 11},
{"_conquer_conquerParaScadSeq", (DL_FUNC) &_conquer_conquerParaScadSeq, 11},
{"_conquer_conquerParaMcp", (DL_FUNC) &_conquer_conquerParaMcp, 11},
{"_conquer_conquerParaMcpSeq", (DL_FUNC) &_conquer_conquerParaMcpSeq, 11},
{"_conquer_cvParaLassoWarm", (DL_FUNC) &_conquer_cvParaLassoWarm, 11},
{"_conquer_cvParaElasticWarm", (DL_FUNC) &_conquer_cvParaElasticWarm, 12},
{"_conquer_cvParaGroupLassoWarm", (DL_FUNC) &_conquer_cvParaGroupLassoWarm, 14},
{"_conquer_cvParaSparseGroupLassoWarm", (DL_FUNC) &_conquer_cvParaSparseGroupLassoWarm, 14},
{"_conquer_cvParaScadWarm", (DL_FUNC) &_conquer_cvParaScadWarm, 13},
{"_conquer_cvParaMcpWarm", (DL_FUNC) &_conquer_cvParaMcpWarm, 13},
{"_conquer_lossTrianHd", (DL_FUNC) &_conquer_lossTrianHd, 7},
{"_conquer_updateTrianHd", (DL_FUNC) &_conquer_updateTrianHd, 9},
{"_conquer_lammTrianLasso", (DL_FUNC) &_conquer_lammTrianLasso, 12},
{"_conquer_lammTrianElastic", (DL_FUNC) &_conquer_lammTrianElastic, 13},
{"_conquer_lammTrianGroupLasso", (DL_FUNC) &_conquer_lammTrianGroupLasso, 15},
{"_conquer_lammTrianSparseGroupLasso", (DL_FUNC) &_conquer_lammTrianSparseGroupLasso, 16},
{"_conquer_trianLasso", (DL_FUNC) &_conquer_trianLasso, 13},
{"_conquer_trianLassoWarm", (DL_FUNC) &_conquer_trianLassoWarm, 14},
{"_conquer_trianElastic", (DL_FUNC) &_conquer_trianElastic, 14},
{"_conquer_trianElasticWarm", (DL_FUNC) &_conquer_trianElasticWarm, 15},
{"_conquer_trianGroupLasso", (DL_FUNC) &_conquer_trianGroupLasso, 16},
{"_conquer_trianGroupLassoWarm", (DL_FUNC) &_conquer_trianGroupLassoWarm, 17},
{"_conquer_trianSparseGroupLasso", (DL_FUNC) &_conquer_trianSparseGroupLasso, 16},
{"_conquer_trianSparseGroupLassoWarm", (DL_FUNC) &_conquer_trianSparseGroupLassoWarm, 17},
{"_conquer_trianScad", (DL_FUNC) &_conquer_trianScad, 15},
{"_conquer_trianScadWarm", (DL_FUNC) &_conquer_trianScadWarm, 15},
{"_conquer_trianMcp", (DL_FUNC) &_conquer_trianMcp, 15},
{"_conquer_trianMcpWarm", (DL_FUNC) &_conquer_trianMcpWarm, 15},
{"_conquer_conquerTrianLasso", (DL_FUNC) &_conquer_conquerTrianLasso, 9},
{"_conquer_conquerTrianLassoSeq", (DL_FUNC) &_conquer_conquerTrianLassoSeq, 9},
{"_conquer_conquerTrianElastic", (DL_FUNC) &_conquer_conquerTrianElastic, 10},
{"_conquer_conquerTrianElasticSeq", (DL_FUNC) &_conquer_conquerTrianElasticSeq, 10},
{"_conquer_conquerTrianGroupLasso", (DL_FUNC) &_conquer_conquerTrianGroupLasso, 12},
{"_conquer_conquerTrianGroupLassoSeq", (DL_FUNC) &_conquer_conquerTrianGroupLassoSeq, 12},
{"_conquer_conquerTrianSparseGroupLasso", (DL_FUNC) &_conquer_conquerTrianSparseGroupLasso, 12},
{"_conquer_conquerTrianSparseGroupLassoSeq", (DL_FUNC) &_conquer_conquerTrianSparseGroupLassoSeq, 12},
{"_conquer_conquerTrianScad", (DL_FUNC) &_conquer_conquerTrianScad, 11},
{"_conquer_conquerTrianScadSeq", (DL_FUNC) &_conquer_conquerTrianScadSeq, 11},
{"_conquer_conquerTrianMcp", (DL_FUNC) &_conquer_conquerTrianMcp, 11},
{"_conquer_conquerTrianMcpSeq", (DL_FUNC) &_conquer_conquerTrianMcpSeq, 11},
{"_conquer_cvTrianLassoWarm", (DL_FUNC) &_conquer_cvTrianLassoWarm, 11},
{"_conquer_cvTrianElasticWarm", (DL_FUNC) &_conquer_cvTrianElasticWarm, 12},
{"_conquer_cvTrianGroupLassoWarm", (DL_FUNC) &_conquer_cvTrianGroupLassoWarm, 14},
{"_conquer_cvTrianSparseGroupLassoWarm", (DL_FUNC) &_conquer_cvTrianSparseGroupLassoWarm, 14},
{"_conquer_cvTrianScadWarm", (DL_FUNC) &_conquer_cvTrianScadWarm, 13},
{"_conquer_cvTrianMcpWarm", (DL_FUNC) &_conquer_cvTrianMcpWarm, 13},
{"_conquer_lossUnifHd", (DL_FUNC) &_conquer_lossUnifHd, 6},
{"_conquer_updateUnifHd", (DL_FUNC) &_conquer_updateUnifHd, 8},
{"_conquer_lammUnifLasso", (DL_FUNC) &_conquer_lammUnifLasso, 11},
{"_conquer_lammUnifElastic", (DL_FUNC) &_conquer_lammUnifElastic, 12},
{"_conquer_lammUnifGroupLasso", (DL_FUNC) &_conquer_lammUnifGroupLasso, 14},
{"_conquer_lammUnifSparseGroupLasso", (DL_FUNC) &_conquer_lammUnifSparseGroupLasso, 15},
{"_conquer_unifLasso", (DL_FUNC) &_conquer_unifLasso, 12},
{"_conquer_unifLassoWarm", (DL_FUNC) &_conquer_unifLassoWarm, 13},
{"_conquer_unifElastic", (DL_FUNC) &_conquer_unifElastic, 13},
{"_conquer_unifElasticWarm", (DL_FUNC) &_conquer_unifElasticWarm, 14},
{"_conquer_unifGroupLasso", (DL_FUNC) &_conquer_unifGroupLasso, 15},
{"_conquer_unifGroupLassoWarm", (DL_FUNC) &_conquer_unifGroupLassoWarm, 16},
{"_conquer_unifSparseGroupLasso", (DL_FUNC) &_conquer_unifSparseGroupLasso, 15},
{"_conquer_unifSparseGroupLassoWarm", (DL_FUNC) &_conquer_unifSparseGroupLassoWarm, 16},
{"_conquer_unifScad", (DL_FUNC) &_conquer_unifScad, 14},
{"_conquer_unifScadWarm", (DL_FUNC) &_conquer_unifScadWarm, 14},
{"_conquer_unifMcp", (DL_FUNC) &_conquer_unifMcp, 14},
{"_conquer_unifMcpWarm", (DL_FUNC) &_conquer_unifMcpWarm, 14},
{"_conquer_conquerUnifLasso", (DL_FUNC) &_conquer_conquerUnifLasso, 9},
{"_conquer_conquerUnifLassoSeq", (DL_FUNC) &_conquer_conquerUnifLassoSeq, 9},
{"_conquer_conquerUnifElastic", (DL_FUNC) &_conquer_conquerUnifElastic, 10},
{"_conquer_conquerUnifElasticSeq", (DL_FUNC) &_conquer_conquerUnifElasticSeq, 10},
{"_conquer_conquerUnifGroupLasso", (DL_FUNC) &_conquer_conquerUnifGroupLasso, 12},
{"_conquer_conquerUnifGroupLassoSeq", (DL_FUNC) &_conquer_conquerUnifGroupLassoSeq, 12},
{"_conquer_conquerUnifSparseGroupLasso", (DL_FUNC) &_conquer_conquerUnifSparseGroupLasso, 12},
{"_conquer_conquerUnifSparseGroupLassoSeq", (DL_FUNC) &_conquer_conquerUnifSparseGroupLassoSeq, 12},
{"_conquer_conquerUnifScad", (DL_FUNC) &_conquer_conquerUnifScad, 11},
{"_conquer_conquerUnifScadSeq", (DL_FUNC) &_conquer_conquerUnifScadSeq, 11},
{"_conquer_conquerUnifMcp", (DL_FUNC) &_conquer_conquerUnifMcp, 11},
{"_conquer_conquerUnifMcpSeq", (DL_FUNC) &_conquer_conquerUnifMcpSeq, 11},
{"_conquer_cvUnifLassoWarm", (DL_FUNC) &_conquer_cvUnifLassoWarm, 11},
{"_conquer_cvUnifElasticWarm", (DL_FUNC) &_conquer_cvUnifElasticWarm, 12},
{"_conquer_cvUnifGroupLassoWarm", (DL_FUNC) &_conquer_cvUnifGroupLassoWarm, 14},
{"_conquer_cvUnifSparseGroupLassoWarm", (DL_FUNC) &_conquer_cvUnifSparseGroupLassoWarm, 14},
{"_conquer_cvUnifScadWarm", (DL_FUNC) &_conquer_cvUnifScadWarm, 13},
{"_conquer_cvUnifMcpWarm", (DL_FUNC) &_conquer_cvUnifMcpWarm, 13},
{"_conquer_updateHuber", (DL_FUNC) &_conquer_updateHuber, 8},
{"_conquer_updateGauss", (DL_FUNC) &_conquer_updateGauss, 7},
{"_conquer_updateLogistic", (DL_FUNC) &_conquer_updateLogistic, 7},
{"_conquer_updateUnif", (DL_FUNC) &_conquer_updateUnif, 9},
{"_conquer_updatePara", (DL_FUNC) &_conquer_updatePara, 10},
{"_conquer_updateTrian", (DL_FUNC) &_conquer_updateTrian, 10},
{"_conquer_huberReg", (DL_FUNC) &_conquer_huberReg, 13},
{"_conquer_smqrGauss", (DL_FUNC) &_conquer_smqrGauss, 8},
{"_conquer_smqrGaussNsd", (DL_FUNC) &_conquer_smqrGaussNsd, 8},
{"_conquer_smqrGaussIni", (DL_FUNC) &_conquer_smqrGaussIni, 9},
{"_conquer_smqrLogistic", (DL_FUNC) &_conquer_smqrLogistic, 8},
{"_conquer_smqrLogisticNsd", (DL_FUNC) &_conquer_smqrLogisticNsd, 8},
{"_conquer_smqrLogisticIni", (DL_FUNC) &_conquer_smqrLogisticIni, 9},
{"_conquer_smqrUnif", (DL_FUNC) &_conquer_smqrUnif, 8},
{"_conquer_smqrUnifNsd", (DL_FUNC) &_conquer_smqrUnifNsd, 8},
{"_conquer_smqrUnifIni", (DL_FUNC) &_conquer_smqrUnifIni, 9},
{"_conquer_smqrPara", (DL_FUNC) &_conquer_smqrPara, 8},
{"_conquer_smqrParaNsd", (DL_FUNC) &_conquer_smqrParaNsd, 8},
{"_conquer_smqrParaIni", (DL_FUNC) &_conquer_smqrParaIni, 9},
{"_conquer_smqrTrian", (DL_FUNC) &_conquer_smqrTrian, 8},
{"_conquer_smqrTrianNsd", (DL_FUNC) &_conquer_smqrTrianNsd, 8},
{"_conquer_smqrTrianIni", (DL_FUNC) &_conquer_smqrTrianIni, 9},
{"_conquer_smqrGaussProc", (DL_FUNC) &_conquer_smqrGaussProc, 8},
{"_conquer_smqrLogisticProc", (DL_FUNC) &_conquer_smqrLogisticProc, 8},
{"_conquer_smqrUnifProc", (DL_FUNC) &_conquer_smqrUnifProc, 8},
{"_conquer_smqrParaProc", (DL_FUNC) &_conquer_smqrParaProc, 8},
{"_conquer_smqrTrianProc", (DL_FUNC) &_conquer_smqrTrianProc, 8},
{"_conquer_smqrGaussInf", (DL_FUNC) &_conquer_smqrGaussInf, 11},
{"_conquer_smqrLogisticInf", (DL_FUNC) &_conquer_smqrLogisticInf, 11},
{"_conquer_smqrUnifInf", (DL_FUNC) &_conquer_smqrUnifInf, 11},
{"_conquer_smqrParaInf", (DL_FUNC) &_conquer_smqrParaInf, 11},
{"_conquer_smqrTrianInf", (DL_FUNC) &_conquer_smqrTrianInf, 11},
{"_conquer_huberRegUbd", (DL_FUNC) &_conquer_huberRegUbd, 12},
{"_conquer_smqrGaussUbd", (DL_FUNC) &_conquer_smqrGaussUbd, 7},
{"_conquer_smqrGaussNsdUbd", (DL_FUNC) &_conquer_smqrGaussNsdUbd, 7},
{"_conquer_smqrGaussIniUbd", (DL_FUNC) &_conquer_smqrGaussIniUbd, 8},
{"_conquer_smqrLogisticUbd", (DL_FUNC) &_conquer_smqrLogisticUbd, 7},
{"_conquer_smqrLogisticNsdUbd", (DL_FUNC) &_conquer_smqrLogisticNsdUbd, 7},
{"_conquer_smqrLogisticIniUbd", (DL_FUNC) &_conquer_smqrLogisticIniUbd, 8},
{"_conquer_smqrUnifUbd", (DL_FUNC) &_conquer_smqrUnifUbd, 7},
{"_conquer_smqrUnifNsdUbd", (DL_FUNC) &_conquer_smqrUnifNsdUbd, 7},
{"_conquer_smqrUnifIniUbd", (DL_FUNC) &_conquer_smqrUnifIniUbd, 8},
{"_conquer_smqrParaUbd", (DL_FUNC) &_conquer_smqrParaUbd, 7},
{"_conquer_smqrParaNsdUbd", (DL_FUNC) &_conquer_smqrParaNsdUbd, 7},
{"_conquer_smqrParaIniUbd", (DL_FUNC) &_conquer_smqrParaIniUbd, 8},
{"_conquer_smqrTrianUbd", (DL_FUNC) &_conquer_smqrTrianUbd, 7},
{"_conquer_smqrTrianNsdUbd", (DL_FUNC) &_conquer_smqrTrianNsdUbd, 7},
{"_conquer_smqrTrianIniUbd", (DL_FUNC) &_conquer_smqrTrianIniUbd, 8},
{"_conquer_smqrGaussProcUbd", (DL_FUNC) &_conquer_smqrGaussProcUbd, 7},
{"_conquer_smqrLogisticProcUbd", (DL_FUNC) &_conquer_smqrLogisticProcUbd, 7},
{"_conquer_smqrUnifProcUbd", (DL_FUNC) &_conquer_smqrUnifProcUbd, 7},
{"_conquer_smqrParaProcUbd", (DL_FUNC) &_conquer_smqrParaProcUbd, 7},
{"_conquer_smqrTrianProcUbd", (DL_FUNC) &_conquer_smqrTrianProcUbd, 7},
{"_conquer_smqrGaussInfUbd", (DL_FUNC) &_conquer_smqrGaussInfUbd, 10},
{"_conquer_smqrLogisticInfUbd", (DL_FUNC) &_conquer_smqrLogisticInfUbd, 10},
{"_conquer_smqrUnifInfUbd", (DL_FUNC) &_conquer_smqrUnifInfUbd, 10},
{"_conquer_smqrParaInfUbd", (DL_FUNC) &_conquer_smqrParaInfUbd, 10},
{"_conquer_smqrTrianInfUbd", (DL_FUNC) &_conquer_smqrTrianInfUbd, 10},
{"_conquer_asymptoticCI", (DL_FUNC) &_conquer_asymptoticCI, 7},
{NULL, NULL, 0}
};
RcppExport void R_init_conquer(DllInfo *dll) {
R_registerRoutines(dll, NULL, CallEntries, NULL, NULL);
R_useDynamicSymbols(dll, FALSE);
}
conquer/R/ 0000755 0001762 0000144 00000000000 14401306545 012131 5 ustar ligges users conquer/R/generate_ns.R 0000644 0001762 0000144 00000000300 14202027225 014531 0 ustar ligges users #' @useDynLib conquer
#' @importFrom Rcpp evalCpp
#' @importFrom matrixStats rowSds rowQuantiles rowMaxs colSds
#' @importFrom stats qnorm quantile runif
#' @importFrom Matrix rankMatrix
NULL
conquer/R/RcppExports.R 0000644 0001762 0000144 00000171434 14401306541 014553 0 ustar ligges users # Generated by using Rcpp::compileAttributes() -> do not edit by hand
# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393
sgn <- function(x) {
.Call('_conquer_sgn', PACKAGE = 'conquer', x)
}
mad <- function(x) {
.Call('_conquer_mad', PACKAGE = 'conquer', x)
}
standardize <- function(X, mx, sx1, p) {
.Call('_conquer_standardize', PACKAGE = 'conquer', X, mx, sx1, p)
}
softThresh <- function(x, Lambda, p) {
.Call('_conquer_softThresh', PACKAGE = 'conquer', x, Lambda, p)
}
lossQr <- function(Z, Y, beta, tau, i, dev, devsq) {
invisible(.Call('_conquer_lossQr', PACKAGE = 'conquer', Z, Y, beta, tau, i, dev, devsq))
}
cmptLambdaLasso <- function(lambda, p) {
.Call('_conquer_cmptLambdaLasso', PACKAGE = 'conquer', lambda, p)
}
lossL2 <- function(Z, Y, beta, n1, tau) {
.Call('_conquer_lossL2', PACKAGE = 'conquer', Z, Y, beta, n1, tau)
}
updateL2 <- function(Z, Y, beta, grad, n1, tau) {
.Call('_conquer_updateL2', PACKAGE = 'conquer', Z, Y, beta, grad, n1, tau)
}
lammL2 <- function(Z, Y, Lambda, beta, tau, phi, gamma, p, n1) {
.Call('_conquer_lammL2', PACKAGE = 'conquer', Z, Y, Lambda, beta, tau, phi, gamma, p, n1)
}
lasso <- function(Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax) {
.Call('_conquer_lasso', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, phi0, gamma, epsilon, iteMax)
}
cmptLambdaSCAD <- function(beta, lambda, p, para) {
.Call('_conquer_cmptLambdaSCAD', PACKAGE = 'conquer', beta, lambda, p, para)
}
cmptLambdaMCP <- function(beta, lambda, p, para) {
.Call('_conquer_cmptLambdaMCP', PACKAGE = 'conquer', beta, lambda, p, para)
}
lossGaussHd <- function(Z, Y, beta, tau, h, h1, h2) {
.Call('_conquer_lossGaussHd', PACKAGE = 'conquer', Z, Y, beta, tau, h, h1, h2)
}
updateGaussHd <- function(Z, Y, beta, grad, tau, n1, h, h1, h2) {
.Call('_conquer_updateGaussHd', PACKAGE = 'conquer', Z, Y, beta, grad, tau, n1, h, h1, h2)
}
lammGaussLasso <- function(Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1, h2) {
.Call('_conquer_lammGaussLasso', PACKAGE = 'conquer', Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1, h2)
}
lammGaussElastic <- function(Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1, h2) {
.Call('_conquer_lammGaussElastic', PACKAGE = 'conquer', Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1, h2)
}
lammGaussGroupLasso <- function(Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2) {
.Call('_conquer_lammGaussGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2)
}
lammGaussSparseGroupLasso <- function(Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2) {
.Call('_conquer_lammGaussSparseGroupLasso', PACKAGE = 'conquer', Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2)
}
gaussLasso <- function(Z, Y, lambda, tau, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_gaussLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
gaussLassoWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_gaussLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
gaussElastic <- function(Z, Y, lambda, tau, alpha, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_gaussElastic', PACKAGE = 'conquer', Z, Y, lambda, tau, alpha, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
gaussElasticWarm <- function(Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_gaussElasticWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
gaussGroupLasso <- function(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_gaussGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
gaussGroupLassoWarm <- function(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_gaussGroupLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
gaussSparseGroupLasso <- function(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_gaussSparseGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
gaussSparseGroupLassoWarm <- function(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_gaussSparseGroupLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
gaussScad <- function(Z, Y, lambda, tau, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_gaussScad', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para)
}
gaussScadWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, para = 3.7) {
.Call('_conquer_gaussScadWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, para)
}
gaussMcp <- function(Z, Y, lambda, tau, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3) {
.Call('_conquer_gaussMcp', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para)
}
gaussMcpWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, para = 3) {
.Call('_conquer_gaussMcpWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, para)
}
conquerGaussLasso <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerGaussLasso', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
}
conquerGaussLassoSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerGaussLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax)
}
conquerGaussElastic <- function(X, Y, lambda, tau, alpha, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerGaussElastic', PACKAGE = 'conquer', X, Y, lambda, tau, alpha, h, phi0, gamma, epsilon, iteMax)
}
conquerGaussElasticSeq <- function(X, Y, lambdaSeq, tau, alpha, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerGaussElasticSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, alpha, h, phi0, gamma, epsilon, iteMax)
}
conquerGaussGroupLasso <- function(X, Y, lambda, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerGaussGroupLasso', PACKAGE = 'conquer', X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerGaussGroupLassoSeq <- function(X, Y, lambdaSeq, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerGaussGroupLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerGaussSparseGroupLasso <- function(X, Y, lambda, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerGaussSparseGroupLasso', PACKAGE = 'conquer', X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerGaussSparseGroupLassoSeq <- function(X, Y, lambdaSeq, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerGaussSparseGroupLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerGaussScad <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_conquerGaussScad', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerGaussScadSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_conquerGaussScadSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerGaussMcp <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.0) {
.Call('_conquer_conquerGaussMcp', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerGaussMcpSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.0) {
.Call('_conquer_conquerGaussMcpSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
cvGaussLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvGaussLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax)
}
cvGaussElasticWarm <- function(X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvGaussElasticWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0, gamma, epsilon, iteMax)
}
cvGaussGroupLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvGaussGroupLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
cvGaussSparseGroupLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvGaussSparseGroupLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
cvGaussScadWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_cvGaussScadWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
cvGaussMcpWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.5, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3) {
.Call('_conquer_cvGaussMcpWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
lossLogisticHd <- function(Z, Y, beta, tau, h, h1) {
.Call('_conquer_lossLogisticHd', PACKAGE = 'conquer', Z, Y, beta, tau, h, h1)
}
updateLogisticHd <- function(Z, Y, beta, grad, tau, n1, h, h1) {
.Call('_conquer_updateLogisticHd', PACKAGE = 'conquer', Z, Y, beta, grad, tau, n1, h, h1)
}
lammLogisticLasso <- function(Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1) {
.Call('_conquer_lammLogisticLasso', PACKAGE = 'conquer', Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1)
}
lammLogisticElastic <- function(Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1) {
.Call('_conquer_lammLogisticElastic', PACKAGE = 'conquer', Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1)
}
lammLogisticGroupLasso <- function(Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1) {
.Call('_conquer_lammLogisticGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1)
}
lammLogisticSparseGroupLasso <- function(Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1) {
.Call('_conquer_lammLogisticSparseGroupLasso', PACKAGE = 'conquer', Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1)
}
logisticLasso <- function(Z, Y, lambda, tau, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_logisticLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
logisticLassoWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_logisticLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
logisticElastic <- function(Z, Y, lambda, tau, alpha, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_logisticElastic', PACKAGE = 'conquer', Z, Y, lambda, tau, alpha, p, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
logisticElasticWarm <- function(Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_logisticElasticWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
logisticGroupLasso <- function(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_logisticGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
logisticGroupLassoWarm <- function(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_logisticGroupLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
logisticSparseGroupLasso <- function(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_logisticSparseGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
logisticSparseGroupLassoWarm <- function(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_logisticSparseGroupLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
logisticScad <- function(Z, Y, lambda, tau, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_logisticScad', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para)
}
logisticScadWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, para = 3.7) {
.Call('_conquer_logisticScadWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, para)
}
logisticMcp <- function(Z, Y, lambda, tau, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3) {
.Call('_conquer_logisticMcp', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para)
}
logisticMcpWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, para = 3) {
.Call('_conquer_logisticMcpWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, para)
}
conquerLogisticLasso <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerLogisticLasso', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
}
conquerLogisticLassoSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerLogisticLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax)
}
conquerLogisticElastic <- function(X, Y, lambda, tau, alpha, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerLogisticElastic', PACKAGE = 'conquer', X, Y, lambda, tau, alpha, h, phi0, gamma, epsilon, iteMax)
}
conquerLogisticElasticSeq <- function(X, Y, lambdaSeq, tau, alpha, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerLogisticElasticSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, alpha, h, phi0, gamma, epsilon, iteMax)
}
conquerLogisticGroupLasso <- function(X, Y, lambda, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerLogisticGroupLasso', PACKAGE = 'conquer', X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerLogisticGroupLassoSeq <- function(X, Y, lambdaSeq, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerLogisticGroupLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerLogisticSparseGroupLasso <- function(X, Y, lambda, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerLogisticSparseGroupLasso', PACKAGE = 'conquer', X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerLogisticSparseGroupLassoSeq <- function(X, Y, lambdaSeq, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerLogisticSparseGroupLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerLogisticScad <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_conquerLogisticScad', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerLogisticScadSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_conquerLogisticScadSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerLogisticMcp <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.0) {
.Call('_conquer_conquerLogisticMcp', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerLogisticMcpSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.0) {
.Call('_conquer_conquerLogisticMcpSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
cvLogisticLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvLogisticLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax)
}
cvLogisticElasticWarm <- function(X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvLogisticElasticWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0, gamma, epsilon, iteMax)
}
cvLogisticGroupLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvLogisticGroupLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
cvLogisticSparseGroupLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvLogisticSparseGroupLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
cvLogisticScadWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_cvLogisticScadWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
cvLogisticMcpWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.5, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3) {
.Call('_conquer_cvLogisticMcpWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
lossParaHd <- function(Z, Y, beta, tau, h, h1, h3) {
.Call('_conquer_lossParaHd', PACKAGE = 'conquer', Z, Y, beta, tau, h, h1, h3)
}
updateParaHd <- function(Z, Y, beta, grad, tau, n1, h, h1, h3) {
.Call('_conquer_updateParaHd', PACKAGE = 'conquer', Z, Y, beta, grad, tau, n1, h, h1, h3)
}
lammParaLasso <- function(Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1, h3) {
.Call('_conquer_lammParaLasso', PACKAGE = 'conquer', Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1, h3)
}
lammParaElastic <- function(Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1, h3) {
.Call('_conquer_lammParaElastic', PACKAGE = 'conquer', Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1, h3)
}
lammParaGroupLasso <- function(Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h3) {
.Call('_conquer_lammParaGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h3)
}
lammParaSparseGroupLasso <- function(Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h3) {
.Call('_conquer_lammParaSparseGroupLasso', PACKAGE = 'conquer', Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h3)
}
paraLasso <- function(Z, Y, lambda, tau, p, n1, h, h1, h3, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_paraLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax)
}
paraLassoWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h3, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_paraLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax)
}
paraElastic <- function(Z, Y, lambda, tau, alpha, p, n1, h, h1, h3, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_paraElastic', PACKAGE = 'conquer', Z, Y, lambda, tau, alpha, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax)
}
paraElasticWarm <- function(Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, h3, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_paraElasticWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax)
}
paraGroupLasso <- function(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h3, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_paraGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h3, phi0, gamma, epsilon, iteMax)
}
paraGroupLassoWarm <- function(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h3, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_paraGroupLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h3, phi0, gamma, epsilon, iteMax)
}
paraSparseGroupLasso <- function(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h3, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_paraSparseGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h3, phi0, gamma, epsilon, iteMax)
}
paraSparseGroupLassoWarm <- function(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h3, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_paraSparseGroupLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h3, phi0, gamma, epsilon, iteMax)
}
paraScad <- function(Z, Y, lambda, tau, p, n1, h, h1, h3, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_paraScad', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para)
}
paraScadWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h3, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, para = 3.7) {
.Call('_conquer_paraScadWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax, para)
}
paraMcp <- function(Z, Y, lambda, tau, p, n1, h, h1, h3, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3) {
.Call('_conquer_paraMcp', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax, iteTight, para)
}
paraMcpWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h3, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, para = 3) {
.Call('_conquer_paraMcpWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h3, phi0, gamma, epsilon, iteMax, para)
}
conquerParaLasso <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerParaLasso', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
}
conquerParaLassoSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerParaLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax)
}
conquerParaElastic <- function(X, Y, lambda, tau, alpha, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerParaElastic', PACKAGE = 'conquer', X, Y, lambda, tau, alpha, h, phi0, gamma, epsilon, iteMax)
}
conquerParaElasticSeq <- function(X, Y, lambdaSeq, tau, alpha, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerParaElasticSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, alpha, h, phi0, gamma, epsilon, iteMax)
}
conquerParaGroupLasso <- function(X, Y, lambda, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerParaGroupLasso', PACKAGE = 'conquer', X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerParaGroupLassoSeq <- function(X, Y, lambdaSeq, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerParaGroupLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerParaSparseGroupLasso <- function(X, Y, lambda, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerParaSparseGroupLasso', PACKAGE = 'conquer', X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerParaSparseGroupLassoSeq <- function(X, Y, lambdaSeq, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerParaSparseGroupLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerParaScad <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_conquerParaScad', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerParaScadSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_conquerParaScadSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerParaMcp <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.0) {
.Call('_conquer_conquerParaMcp', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerParaMcpSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.0) {
.Call('_conquer_conquerParaMcpSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
cvParaLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvParaLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax)
}
cvParaElasticWarm <- function(X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvParaElasticWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0, gamma, epsilon, iteMax)
}
cvParaGroupLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvParaGroupLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
cvParaSparseGroupLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvParaSparseGroupLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
cvParaScadWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_cvParaScadWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
cvParaMcpWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.5, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3) {
.Call('_conquer_cvParaMcpWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
lossTrianHd <- function(Z, Y, beta, tau, h, h1, h2) {
.Call('_conquer_lossTrianHd', PACKAGE = 'conquer', Z, Y, beta, tau, h, h1, h2)
}
updateTrianHd <- function(Z, Y, beta, grad, tau, n1, h, h1, h2) {
.Call('_conquer_updateTrianHd', PACKAGE = 'conquer', Z, Y, beta, grad, tau, n1, h, h1, h2)
}
lammTrianLasso <- function(Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1, h2) {
.Call('_conquer_lammTrianLasso', PACKAGE = 'conquer', Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1, h2)
}
lammTrianElastic <- function(Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1, h2) {
.Call('_conquer_lammTrianElastic', PACKAGE = 'conquer', Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1, h2)
}
lammTrianGroupLasso <- function(Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2) {
.Call('_conquer_lammTrianGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2)
}
lammTrianSparseGroupLasso <- function(Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2) {
.Call('_conquer_lammTrianSparseGroupLasso', PACKAGE = 'conquer', Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1, h2)
}
trianLasso <- function(Z, Y, lambda, tau, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_trianLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
trianLassoWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_trianLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
trianElastic <- function(Z, Y, lambda, tau, alpha, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_trianElastic', PACKAGE = 'conquer', Z, Y, lambda, tau, alpha, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
trianElasticWarm <- function(Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_trianElasticWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
trianGroupLasso <- function(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_trianGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
trianGroupLassoWarm <- function(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_trianGroupLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
trianSparseGroupLasso <- function(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_trianSparseGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
trianSparseGroupLassoWarm <- function(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_trianSparseGroupLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, h2, phi0, gamma, epsilon, iteMax)
}
trianScad <- function(Z, Y, lambda, tau, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_trianScad', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para)
}
trianScadWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, para = 3.7) {
.Call('_conquer_trianScadWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, para)
}
trianMcp <- function(Z, Y, lambda, tau, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3) {
.Call('_conquer_trianMcp', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, iteTight, para)
}
trianMcpWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, para = 3) {
.Call('_conquer_trianMcpWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, h2, phi0, gamma, epsilon, iteMax, para)
}
conquerTrianLasso <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerTrianLasso', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
}
conquerTrianLassoSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerTrianLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax)
}
conquerTrianElastic <- function(X, Y, lambda, tau, alpha, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerTrianElastic', PACKAGE = 'conquer', X, Y, lambda, tau, alpha, h, phi0, gamma, epsilon, iteMax)
}
conquerTrianElasticSeq <- function(X, Y, lambdaSeq, tau, alpha, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerTrianElasticSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, alpha, h, phi0, gamma, epsilon, iteMax)
}
conquerTrianGroupLasso <- function(X, Y, lambda, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerTrianGroupLasso', PACKAGE = 'conquer', X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerTrianGroupLassoSeq <- function(X, Y, lambdaSeq, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerTrianGroupLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerTrianSparseGroupLasso <- function(X, Y, lambda, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerTrianSparseGroupLasso', PACKAGE = 'conquer', X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerTrianSparseGroupLassoSeq <- function(X, Y, lambdaSeq, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerTrianSparseGroupLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerTrianScad <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_conquerTrianScad', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerTrianScadSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_conquerTrianScadSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerTrianMcp <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.0) {
.Call('_conquer_conquerTrianMcp', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerTrianMcpSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.0) {
.Call('_conquer_conquerTrianMcpSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
cvTrianLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvTrianLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax)
}
cvTrianElasticWarm <- function(X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvTrianElasticWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0, gamma, epsilon, iteMax)
}
cvTrianGroupLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvTrianGroupLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
cvTrianSparseGroupLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvTrianSparseGroupLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
cvTrianScadWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_cvTrianScadWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
cvTrianMcpWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.5, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3) {
.Call('_conquer_cvTrianMcpWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
lossUnifHd <- function(Z, Y, beta, tau, h, h1) {
.Call('_conquer_lossUnifHd', PACKAGE = 'conquer', Z, Y, beta, tau, h, h1)
}
updateUnifHd <- function(Z, Y, beta, grad, tau, n1, h, h1) {
.Call('_conquer_updateUnifHd', PACKAGE = 'conquer', Z, Y, beta, grad, tau, n1, h, h1)
}
lammUnifLasso <- function(Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1) {
.Call('_conquer_lammUnifLasso', PACKAGE = 'conquer', Z, Y, Lambda, beta, tau, phi, gamma, p, h, n1, h1)
}
lammUnifElastic <- function(Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1) {
.Call('_conquer_lammUnifElastic', PACKAGE = 'conquer', Z, Y, Lambda, beta, tau, alpha, phi, gamma, p, h, n1, h1)
}
lammUnifGroupLasso <- function(Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1) {
.Call('_conquer_lammUnifGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1)
}
lammUnifSparseGroupLasso <- function(Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1) {
.Call('_conquer_lammUnifSparseGroupLasso', PACKAGE = 'conquer', Z, Y, Lambda, lambda, beta, tau, group, weight, phi, gamma, p, G, h, n1, h1)
}
unifLasso <- function(Z, Y, lambda, tau, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_unifLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
unifLassoWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_unifLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
unifElastic <- function(Z, Y, lambda, tau, alpha, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_unifElastic', PACKAGE = 'conquer', Z, Y, lambda, tau, alpha, p, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
unifElasticWarm <- function(Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_unifElasticWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, alpha, p, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
unifGroupLasso <- function(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_unifGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
unifGroupLassoWarm <- function(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_unifGroupLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
unifSparseGroupLasso <- function(Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_unifSparseGroupLasso', PACKAGE = 'conquer', Z, Y, lambda, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
unifSparseGroupLassoWarm <- function(Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_unifSparseGroupLassoWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, group, weight, p, G, n1, h, h1, phi0, gamma, epsilon, iteMax)
}
unifScad <- function(Z, Y, lambda, tau, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_unifScad', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para)
}
unifScadWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, para = 3.7) {
.Call('_conquer_unifScadWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, para)
}
unifMcp <- function(Z, Y, lambda, tau, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3) {
.Call('_conquer_unifMcp', PACKAGE = 'conquer', Z, Y, lambda, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, iteTight, para)
}
unifMcpWarm <- function(Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, para = 3) {
.Call('_conquer_unifMcpWarm', PACKAGE = 'conquer', Z, Y, lambda, betaWarm, tau, p, n1, h, h1, phi0, gamma, epsilon, iteMax, para)
}
conquerUnifLasso <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerUnifLasso', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
}
conquerUnifLassoSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerUnifLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax)
}
conquerUnifElastic <- function(X, Y, lambda, tau, alpha, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerUnifElastic', PACKAGE = 'conquer', X, Y, lambda, tau, alpha, h, phi0, gamma, epsilon, iteMax)
}
conquerUnifElasticSeq <- function(X, Y, lambdaSeq, tau, alpha, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerUnifElasticSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, alpha, h, phi0, gamma, epsilon, iteMax)
}
conquerUnifGroupLasso <- function(X, Y, lambda, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerUnifGroupLasso', PACKAGE = 'conquer', X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerUnifGroupLassoSeq <- function(X, Y, lambdaSeq, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerUnifGroupLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerUnifSparseGroupLasso <- function(X, Y, lambda, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerUnifSparseGroupLasso', PACKAGE = 'conquer', X, Y, lambda, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerUnifSparseGroupLassoSeq <- function(X, Y, lambdaSeq, tau, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_conquerUnifSparseGroupLassoSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
conquerUnifScad <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_conquerUnifScad', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerUnifScadSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_conquerUnifScadSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerUnifMcp <- function(X, Y, lambda, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.0) {
.Call('_conquer_conquerUnifMcp', PACKAGE = 'conquer', X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
conquerUnifMcpSeq <- function(X, Y, lambdaSeq, tau, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.0) {
.Call('_conquer_conquerUnifMcpSeq', PACKAGE = 'conquer', X, Y, lambdaSeq, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
cvUnifLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvUnifLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax)
}
cvUnifElasticWarm <- function(X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvUnifElasticWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, alpha, kfolds, h, phi0, gamma, epsilon, iteMax)
}
cvUnifGroupLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvUnifGroupLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
cvUnifSparseGroupLassoWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L) {
.Call('_conquer_cvUnifSparseGroupLassoWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, group, weight, G, h, phi0, gamma, epsilon, iteMax)
}
cvUnifScadWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.2, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3.7) {
.Call('_conquer_cvUnifScadWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
cvUnifMcpWarm <- function(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0 = 0.01, gamma = 1.5, epsilon = 0.001, iteMax = 500L, iteTight = 3L, para = 3) {
.Call('_conquer_cvUnifMcpWarm', PACKAGE = 'conquer', X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para)
}
updateHuber <- function(Z, res, tau, der, grad, n, rob, n1) {
invisible(.Call('_conquer_updateHuber', PACKAGE = 'conquer', Z, res, tau, der, grad, n, rob, n1))
}
updateGauss <- function(Z, res, der, grad, tau, n1, h1) {
invisible(.Call('_conquer_updateGauss', PACKAGE = 'conquer', Z, res, der, grad, tau, n1, h1))
}
updateLogistic <- function(Z, res, der, grad, tau, n1, h1) {
invisible(.Call('_conquer_updateLogistic', PACKAGE = 'conquer', Z, res, der, grad, tau, n1, h1))
}
updateUnif <- function(Z, res, der, grad, n, tau, h, n1, h1) {
invisible(.Call('_conquer_updateUnif', PACKAGE = 'conquer', Z, res, der, grad, n, tau, h, n1, h1))
}
updatePara <- function(Z, res, der, grad, n, tau, h, n1, h1, h3) {
invisible(.Call('_conquer_updatePara', PACKAGE = 'conquer', Z, res, der, grad, n, tau, h, n1, h1, h3))
}
updateTrian <- function(Z, res, der, grad, n, tau, h, n1, h1, h2) {
invisible(.Call('_conquer_updateTrian', PACKAGE = 'conquer', Z, res, der, grad, n, tau, h, n1, h1, h2))
}
huberReg <- function(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol = 0.0001, constTau = 1.345, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_huberReg', PACKAGE = 'conquer', Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax, stepMax)
}
smqrGauss <- function(X, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrGauss', PACKAGE = 'conquer', X, Y, tau, h, constTau, tol, iteMax, stepMax)
}
smqrGaussNsd <- function(Z, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrGaussNsd', PACKAGE = 'conquer', Z, Y, tau, h, constTau, tol, iteMax, stepMax)
}
smqrGaussIni <- function(X, Y, betaHat, p, tau = 0.5, h = 0.05, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrGaussIni', PACKAGE = 'conquer', X, Y, betaHat, p, tau, h, tol, iteMax, stepMax)
}
smqrLogistic <- function(X, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrLogistic', PACKAGE = 'conquer', X, Y, tau, h, constTau, tol, iteMax, stepMax)
}
smqrLogisticNsd <- function(Z, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrLogisticNsd', PACKAGE = 'conquer', Z, Y, tau, h, constTau, tol, iteMax, stepMax)
}
smqrLogisticIni <- function(X, Y, betaHat, p, tau = 0.5, h = 0.05, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrLogisticIni', PACKAGE = 'conquer', X, Y, betaHat, p, tau, h, tol, iteMax, stepMax)
}
smqrUnif <- function(X, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrUnif', PACKAGE = 'conquer', X, Y, tau, h, constTau, tol, iteMax, stepMax)
}
smqrUnifNsd <- function(Z, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrUnifNsd', PACKAGE = 'conquer', Z, Y, tau, h, constTau, tol, iteMax, stepMax)
}
smqrUnifIni <- function(X, Y, betaHat, p, tau = 0.5, h = 0.05, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrUnifIni', PACKAGE = 'conquer', X, Y, betaHat, p, tau, h, tol, iteMax, stepMax)
}
smqrPara <- function(X, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrPara', PACKAGE = 'conquer', X, Y, tau, h, constTau, tol, iteMax, stepMax)
}
smqrParaNsd <- function(Z, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrParaNsd', PACKAGE = 'conquer', Z, Y, tau, h, constTau, tol, iteMax, stepMax)
}
smqrParaIni <- function(X, Y, betaHat, p, tau = 0.5, h = 0.05, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrParaIni', PACKAGE = 'conquer', X, Y, betaHat, p, tau, h, tol, iteMax, stepMax)
}
smqrTrian <- function(X, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrTrian', PACKAGE = 'conquer', X, Y, tau, h, constTau, tol, iteMax, stepMax)
}
smqrTrianNsd <- function(Z, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrTrianNsd', PACKAGE = 'conquer', Z, Y, tau, h, constTau, tol, iteMax, stepMax)
}
smqrTrianIni <- function(X, Y, betaHat, p, tau = 0.5, h = 0.05, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrTrianIni', PACKAGE = 'conquer', X, Y, betaHat, p, tau, h, tol, iteMax, stepMax)
}
smqrGaussProc <- function(X, Y, tauSeq, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrGaussProc', PACKAGE = 'conquer', X, Y, tauSeq, h, constTau, tol, iteMax, stepMax)
}
smqrLogisticProc <- function(X, Y, tauSeq, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrLogisticProc', PACKAGE = 'conquer', X, Y, tauSeq, h, constTau, tol, iteMax, stepMax)
}
smqrUnifProc <- function(X, Y, tauSeq, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrUnifProc', PACKAGE = 'conquer', X, Y, tauSeq, h, constTau, tol, iteMax, stepMax)
}
smqrParaProc <- function(X, Y, tauSeq, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrParaProc', PACKAGE = 'conquer', X, Y, tauSeq, h, constTau, tol, iteMax, stepMax)
}
smqrTrianProc <- function(X, Y, tauSeq, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrTrianProc', PACKAGE = 'conquer', X, Y, tauSeq, h, constTau, tol, iteMax, stepMax)
}
smqrGaussInf <- function(X, Y, betaHat, n, p, h = 0.05, tau = 0.5, B = 1000L, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrGaussInf', PACKAGE = 'conquer', X, Y, betaHat, n, p, h, tau, B, tol, iteMax, stepMax)
}
smqrLogisticInf <- function(X, Y, betaHat, n, p, h = 0.05, tau = 0.5, B = 1000L, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrLogisticInf', PACKAGE = 'conquer', X, Y, betaHat, n, p, h, tau, B, tol, iteMax, stepMax)
}
smqrUnifInf <- function(X, Y, betaHat, n, p, h = 0.05, tau = 0.5, B = 1000L, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrUnifInf', PACKAGE = 'conquer', X, Y, betaHat, n, p, h, tau, B, tol, iteMax, stepMax)
}
smqrParaInf <- function(X, Y, betaHat, n, p, h = 0.05, tau = 0.5, B = 1000L, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrParaInf', PACKAGE = 'conquer', X, Y, betaHat, n, p, h, tau, B, tol, iteMax, stepMax)
}
smqrTrianInf <- function(X, Y, betaHat, n, p, h = 0.05, tau = 0.5, B = 1000L, tol = 0.0001, iteMax = 5000L, stepMax = 100.0) {
.Call('_conquer_smqrTrianInf', PACKAGE = 'conquer', X, Y, betaHat, n, p, h, tau, B, tol, iteMax, stepMax)
}
huberRegUbd <- function(Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol = 0.0001, constTau = 1.345, iteMax = 5000L) {
.Call('_conquer_huberRegUbd', PACKAGE = 'conquer', Z, Y, tau, der, gradOld, gradNew, n, p, n1, tol, constTau, iteMax)
}
smqrGaussUbd <- function(X, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrGaussUbd', PACKAGE = 'conquer', X, Y, tau, h, constTau, tol, iteMax)
}
smqrGaussNsdUbd <- function(Z, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrGaussNsdUbd', PACKAGE = 'conquer', Z, Y, tau, h, constTau, tol, iteMax)
}
smqrGaussIniUbd <- function(X, Y, betaHat, p, tau = 0.5, h = 0.05, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrGaussIniUbd', PACKAGE = 'conquer', X, Y, betaHat, p, tau, h, tol, iteMax)
}
smqrLogisticUbd <- function(X, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrLogisticUbd', PACKAGE = 'conquer', X, Y, tau, h, constTau, tol, iteMax)
}
smqrLogisticNsdUbd <- function(Z, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrLogisticNsdUbd', PACKAGE = 'conquer', Z, Y, tau, h, constTau, tol, iteMax)
}
smqrLogisticIniUbd <- function(X, Y, betaHat, p, tau = 0.5, h = 0.05, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrLogisticIniUbd', PACKAGE = 'conquer', X, Y, betaHat, p, tau, h, tol, iteMax)
}
smqrUnifUbd <- function(X, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrUnifUbd', PACKAGE = 'conquer', X, Y, tau, h, constTau, tol, iteMax)
}
smqrUnifNsdUbd <- function(Z, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrUnifNsdUbd', PACKAGE = 'conquer', Z, Y, tau, h, constTau, tol, iteMax)
}
smqrUnifIniUbd <- function(X, Y, betaHat, p, tau = 0.5, h = 0.05, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrUnifIniUbd', PACKAGE = 'conquer', X, Y, betaHat, p, tau, h, tol, iteMax)
}
smqrParaUbd <- function(X, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrParaUbd', PACKAGE = 'conquer', X, Y, tau, h, constTau, tol, iteMax)
}
smqrParaNsdUbd <- function(Z, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrParaNsdUbd', PACKAGE = 'conquer', Z, Y, tau, h, constTau, tol, iteMax)
}
smqrParaIniUbd <- function(X, Y, betaHat, p, tau = 0.5, h = 0.05, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrParaIniUbd', PACKAGE = 'conquer', X, Y, betaHat, p, tau, h, tol, iteMax)
}
smqrTrianUbd <- function(X, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrTrianUbd', PACKAGE = 'conquer', X, Y, tau, h, constTau, tol, iteMax)
}
smqrTrianNsdUbd <- function(Z, Y, tau = 0.5, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrTrianNsdUbd', PACKAGE = 'conquer', Z, Y, tau, h, constTau, tol, iteMax)
}
smqrTrianIniUbd <- function(X, Y, betaHat, p, tau = 0.5, h = 0.05, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrTrianIniUbd', PACKAGE = 'conquer', X, Y, betaHat, p, tau, h, tol, iteMax)
}
smqrGaussProcUbd <- function(X, Y, tauSeq, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrGaussProcUbd', PACKAGE = 'conquer', X, Y, tauSeq, h, constTau, tol, iteMax)
}
smqrLogisticProcUbd <- function(X, Y, tauSeq, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrLogisticProcUbd', PACKAGE = 'conquer', X, Y, tauSeq, h, constTau, tol, iteMax)
}
smqrUnifProcUbd <- function(X, Y, tauSeq, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrUnifProcUbd', PACKAGE = 'conquer', X, Y, tauSeq, h, constTau, tol, iteMax)
}
smqrParaProcUbd <- function(X, Y, tauSeq, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrParaProcUbd', PACKAGE = 'conquer', X, Y, tauSeq, h, constTau, tol, iteMax)
}
smqrTrianProcUbd <- function(X, Y, tauSeq, h = 0.05, constTau = 1.345, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrTrianProcUbd', PACKAGE = 'conquer', X, Y, tauSeq, h, constTau, tol, iteMax)
}
smqrGaussInfUbd <- function(X, Y, betaHat, n, p, h = 0.05, tau = 0.5, B = 1000L, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrGaussInfUbd', PACKAGE = 'conquer', X, Y, betaHat, n, p, h, tau, B, tol, iteMax)
}
smqrLogisticInfUbd <- function(X, Y, betaHat, n, p, h = 0.05, tau = 0.5, B = 1000L, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrLogisticInfUbd', PACKAGE = 'conquer', X, Y, betaHat, n, p, h, tau, B, tol, iteMax)
}
smqrUnifInfUbd <- function(X, Y, betaHat, n, p, h = 0.05, tau = 0.5, B = 1000L, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrUnifInfUbd', PACKAGE = 'conquer', X, Y, betaHat, n, p, h, tau, B, tol, iteMax)
}
smqrParaInfUbd <- function(X, Y, betaHat, n, p, h = 0.05, tau = 0.5, B = 1000L, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrParaInfUbd', PACKAGE = 'conquer', X, Y, betaHat, n, p, h, tau, B, tol, iteMax)
}
smqrTrianInfUbd <- function(X, Y, betaHat, n, p, h = 0.05, tau = 0.5, B = 1000L, tol = 0.0001, iteMax = 5000L) {
.Call('_conquer_smqrTrianInfUbd', PACKAGE = 'conquer', X, Y, betaHat, n, p, h, tau, B, tol, iteMax)
}
asymptoticCI <- function(X, res, coeff, tau, n, h, z) {
.Call('_conquer_asymptoticCI', PACKAGE = 'conquer', X, res, coeff, tau, n, h, z)
}
conquer/R/smqr.R 0000644 0001762 0000144 00000160266 14401303530 013240 0 ustar ligges users getPivCI = function(est, estBoot, alpha) {
q1 = rowQuantiles(estBoot, probs = alpha / 2)
q2 = rowQuantiles(estBoot, probs = 1 - alpha / 2)
perCI = cbind(q1, q2)
pivCI = cbind(2 * est - q2, 2 * est - q1)
colnames(perCI) = colnames(pivCI) = c("lower", "upper")
return (list(perCI = perCI, pivCI = pivCI))
}
getNormCI = function(est, sd, z) {
lower = est - z * sd
upper = est + z * sd
return (cbind(lower, upper))
}
#' @title Convolution-Type Smoothed Quantile Regression
#' @description Estimation and inference for conditional linear quantile regression models using a convolution smoothed approach. Efficient gradient-based methods are employed for fitting both a single model and a regression process over a quantile range.
#' Normal-based and (multiplier) bootstrap confidence intervals for all slope coefficients are constructed.
#' @param X An \eqn{n} by \eqn{p} design matrix. Each row is a vector of observations with \eqn{p} covariates. Number of observations \eqn{n} must be greater than number of covariates \eqn{p}.
#' @param Y An \eqn{n}-dimensional response vector.
#' @param tau (\strong{optional}) The desired quantile level. Default is 0.5. Value must be between 0 and 1.
#' @param kernel (\strong{optional}) A character string specifying the choice of kernel function. Default is "Gaussian". Choices are "Gaussian", "logistic", "uniform", "parabolic" and "triangular".
#' @param h (\strong{optional}) Bandwidth/smoothing parameter. Default is \eqn{\max\{((log(n) + p) / n)^{0.4}, 0.05\}}. The default will be used if the input value is less than or equal to 0.
#' @param checkSing (\strong{optional}) A logical flag. Default is FALSE. If \code{checkSing = TRUE}, then it will check if the design matrix is singular before running conquer.
#' @param tol (\strong{optional}) Tolerance level of the gradient descent algorithm. The iteration will stop when the maximum magnitude of all the elements of the gradient is less than \code{tol}. Default is 1e-04.
#' @param iteMax (\strong{optional}) Maximum number of iterations. Default is 5000.
#' @param stepBounded (\strong{optional}) A logical flag. Default is TRUE. If \code{stepBounded = TRUE}, then the step size of gradient descent is upper bounded by \code{stepMax}. If \code{stepBounded = FALSE}, then the step size is unbounded.
#' @param stepMax (\strong{optional}) Maximum bound for the gradient descent step size. Default is 100.
#' @param ci (\strong{optional}) A character string specifying methods to construct confidence intervals. Choices are "none" (default), "bootstrap", "asymptotic" and "both". If \code{ci = "none"}, then confidence intervals will not be constructed.
#' If \code{ci = "bootstrap"}, then three types of confidence intervals (percentile, pivotal and normal) will be constructed via multiplier bootstrap.
#' If \code{ci = "asymptotic"}, then confidence intervals will be constructed based on estimated asymptotic covariance matrix.
#' If \code{ci = "both"}, then confidence intervals from both bootstrap and asymptotic covariance will be returned.
#' @param alpha (\strong{optional}) Miscoverage level for each confidence interval. Default is 0.05.
#' @param B (\strong{optional}) The size of bootstrap samples. Default is 1000.
#' @return An object containing the following items will be returned:
#' \describe{
#' \item{\code{coeff}}{A \eqn{(p + 1)}-vector of estimated quantile regression coefficients, including the intercept.}
#' \item{\code{ite}}{Number of iterations until convergence.}
#' \item{\code{residual}}{An \eqn{n}-vector of fitted residuals.}
#' \item{\code{bandwidth}}{Bandwidth value.}
#' \item{\code{tau}}{Quantile level.}
#' \item{\code{kernel}}{Kernel function.}
#' \item{\code{n}}{Sample size.}
#' \item{\code{p}}{Number of covariates.}
#' \item{\code{perCI}}{The percentile confidence intervals for regression coefficients. Only available if \code{ci = "bootstrap"} or \code{ci = "both"}.}
#' \item{\code{pivCI}}{The pivotal confidence intervals for regression coefficients. Only available if \code{ci = "bootstrap"} or \code{ci = "both"}.}
#' \item{\code{normCI}}{The normal-based confidence intervals for regression coefficients. Only available if \code{ci = "bootstrap"} or \code{ci = "both"}.}
#' \item{\code{asyCI}}{The asymptotic confidence intervals for regression coefficients. Only available if \code{ci = "asymptotic"} or \code{ci = "both"}.}
#' }
#' @references Barzilai, J. and Borwein, J. M. (1988). Two-point step size gradient methods. IMA J. Numer. Anal., 8, 141–148.
#' @references Fernandes, M., Guerre, E. and Horta, E. (2021). Smoothing quantile regressions. J. Bus. Econ. Statist., 39, 338-357.
#' @references He, X., Pan, X., Tan, K. M., and Zhou, W.-X. (2022+). Smoothed quantile regression for large-scale inference. J. Econometrics, in press.
#' @references Koenker, R. and Bassett, G. (1978). Regression quantiles. Econometrica, 46, 33-50.
#' @seealso See \code{\link{conquer.process}} for smoothed quantile regression process.
#' @examples
#' n = 500; p = 10
#' beta = rep(1, p)
#' X = matrix(rnorm(n * p), n, p)
#' Y = X %*% beta + rt(n, 2)
#'
#' ## Smoothed quantile regression with Gaussian kernel
#' fit.Gauss = conquer(X, Y, tau = 0.5, kernel = "Gaussian")
#' beta.hat.Gauss = fit.Gauss$coeff
#'
#' ## Smoothe quantile regression with uniform kernel
#' fit.unif = conquer(X, Y, tau = 0.5, kernel = "uniform")
#' beta.hat.unif = fit.unif$coeff
#'
#' ## Construct three types of confidence intervals via multiplier bootstrap
#' fit = conquer(X, Y, tau = 0.5, kernel = "Gaussian", ci = "bootstrap")
#' ci.per = fit$perCI
#' ci.piv = fit$pivCI
#' ci.norm = fit$normCI
#' @export
conquer = function(X, Y, tau = 0.5, kernel = c("Gaussian", "logistic", "uniform", "parabolic", "triangular"), h = 0.0, checkSing = FALSE, tol = 0.0001,
iteMax = 5000, stepBounded = TRUE, stepMax = 100.0, ci = c("none", "bootstrap", "asymptotic", "both"), alpha = 0.05, B = 1000) {
if (nrow(X) != length(Y)) {
stop("Error: the length of Y must be the same as the number of rows of X.")
}
if (ncol(X) >= nrow(X)) {
stop("Error: the number of columns of X cannot exceed the number of rows of X.")
}
if(tau <= 0 || tau >= 1) {
stop("Error: the quantile level tau must be in (0, 1).")
}
if (alpha <= 0 || alpha >= 1) {
stop("Error: the nominal level alpha must be in (0, 1).")
}
if (min(colSds(X)) == 0) {
stop("Error: at least one column of X is constant.")
}
if (checkSing && rankMatrix(X)[1] < ncol(X)) {
stop("Error: the design matrix X is singular.")
}
kernel = match.arg(kernel)
ci = match.arg(ci)
if (ci == "none") {
rst = NULL
if (kernel == "Gaussian") {
if (stepBounded) {
rst = smqrGauss(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
} else {
rst = smqrGaussUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
}
} else if (kernel == "logistic") {
if (stepBounded) {
rst = smqrLogistic(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
} else {
rst = smqrLogisticUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
}
} else if (kernel == "uniform") {
if (stepBounded) {
rst = smqrUnif(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
} else {
rst = smqrUnifUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
}
} else if (kernel == "parabolic") {
if (stepBounded) {
rst = smqrPara(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
} else {
rst = smqrParaUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
}
} else {
if (stepBounded) {
rst = smqrTrian(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
} else {
rst = smqrTrianUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
}
}
return (list(coeff = as.numeric(rst$coeff), ite = rst$ite, residual = as.numeric(rst$residual), bandwidth = rst$bandwidth, tau = tau,
kernel = kernel, n = nrow(X), p = ncol(X)))
} else if (ci == "bootstrap") {
rst = coeff = multiBeta = NULL
if (kernel == "Gaussian") {
if (stepBounded) {
rst = smqrGauss(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrGaussInf(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax, stepMax)
} else {
rst = smqrGaussUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrGaussInfUbd(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax)
}
} else if (kernel == "logistic") {
if (stepBounded) {
rst = smqrLogistic(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrLogisticInf(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax, stepMax)
} else {
rst = smqrLogisticUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrLogisticInfUbd(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax)
}
} else if (kernel == "uniform") {
if (stepBounded) {
rst = smqrUnif(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrUnifInf(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax, stepMax)
} else {
rst = smqrUnifUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrUnifInfUbd(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax)
}
} else if (kernel == "parabolic") {
if (stepBounded) {
rst = smqrPara(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrParaInf(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax, stepMax)
} else {
rst = smqrParaUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrParaInfUbd(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax)
}
} else {
if (stepBounded) {
rst = smqrTrian(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrTrianInf(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax, stepMax)
} else {
rst = smqrTrianUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrTrianInfUbd(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax)
}
}
ciList = getPivCI(coeff, multiBeta, alpha)
z = qnorm(1 - alpha / 2)
normCI = as.matrix(getNormCI(coeff, rowSds(multiBeta), z))
return (list(coeff = coeff, ite = rst$ite, residual = as.numeric(rst$residual), bandwidth = rst$bandwidth, tau = tau, kernel = kernel,
n = nrow(X), p = ncol(X), perCI = as.matrix(ciList$perCI), pivCI = as.matrix(ciList$pivCI), normCI = normCI))
} else if (ci == "asymptotic") {
rst = coeff = NULL
if (kernel == "Gaussian") {
if (stepBounded) {
rst = smqrGauss(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
} else {
rst = smqrGaussUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
}
} else if (kernel == "logistic") {
if (stepBounded) {
rst = smqrLogistic(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
} else {
rst = smqrLogisticUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
}
} else if (kernel == "uniform") {
if (stepBounded) {
rst = smqrUnif(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
} else {
rst = smqrUnifUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
}
} else if (kernel == "parabolic") {
if (stepBounded) {
rst = smqrPara(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
} else {
rst = smqrParaUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
}
} else {
if (stepBounded) {
rst = smqrTrian(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
} else {
rst = smqrTrianUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
}
}
res = as.numeric(rst$residual)
h = rst$bandwidth
n = nrow(X)
z = qnorm(1 - alpha / 2)
asyCI = asymptoticCI(X, res, coeff, tau, n, h, z)
return (list(coeff = coeff, ite = rst$ite, residual = res, bandwidth = h, tau = tau, kernel = kernel, n = n, p = ncol(X), asyCI = asyCI))
} else {
rst = coeff = multiBeta = NULL
if (kernel == "Gaussian") {
if (stepBounded) {
rst = smqrGauss(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrGaussInf(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax, stepMax)
} else {
rst = smqrGaussUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrGaussInfUbd(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax)
}
} else if (kernel == "logistic") {
if (stepBounded) {
rst = smqrLogistic(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrLogisticInf(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax, stepMax)
} else {
rst = smqrLogisticUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrLogisticInfUbd(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax)
}
} else if (kernel == "uniform") {
if (stepBounded) {
rst = smqrUnif(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrUnifInf(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax, stepMax)
} else {
rst = smqrUnifUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrUnifInfUbd(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax)
}
} else if (kernel == "parabolic") {
if (stepBounded) {
rst = smqrPara(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrParaInf(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax, stepMax)
} else {
rst = smqrParaUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrParaInfUbd(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax)
}
} else {
if (stepBounded) {
rst = smqrTrian(X, Y, tau, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrTrianInf(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax, stepMax)
} else {
rst = smqrTrianUbd(X, Y, tau, h, tol = tol, iteMax = iteMax)
coeff = as.numeric(rst$coeff)
multiBeta = smqrTrianInfUbd(X, Y, coeff, nrow(X), ncol(X), h, tau, B, tol, iteMax)
}
}
ciList = getPivCI(coeff, multiBeta, alpha)
z = qnorm(1 - alpha / 2)
normCI = as.matrix(getNormCI(coeff, rowSds(multiBeta), z))
res = as.numeric(rst$residual)
h = rst$bandwidth
n = nrow(X)
asyCI = asymptoticCI(X, res, coeff, tau, n, h, z)
return (list(coeff = coeff, ite = rst$ite, residual = res, bandwidth = h, tau = tau, kernel = kernel, n = n, p = ncol(X),
perCI = as.matrix(ciList$perCI), pivCI = as.matrix(ciList$pivCI), normCI = normCI, asyCI = asyCI))
}
}
#' @title Convolution-Type Smoothed Quantile Regression Process
#' @description Fit a smoothed quantile regression process over a quantile range. The algorithm is essentially the same as \code{\link{conquer}}.
#' @param X An \eqn{n} by \eqn{p} design matrix. Each row is a vector of observations with \eqn{p} covariates. Number of observations \eqn{n} must be greater than number of covariates \eqn{p}.
#' @param Y An \eqn{n}-dimensional response vector.
#' @param tauSeq (\strong{optional}) A sequence of quantile values (between 0 and 1). Default is \eqn{\{0.1, 0.15, 0.2, ..., 0.85, 0.9\}}.
#' @param kernel (\strong{optional}) A character string specifying the choice of kernel function. Default is "Gaussian". Choices are "Gaussian", "logistic", "uniform", "parabolic" and "triangular".
#' @param h (\strong{optional}) The bandwidth/smoothing parameter. Default is \eqn{\max\{((log(n) + p) / n)^{0.4}, 0.05\}}. The default will be used if the input value is less than or equal to 0.
#' @param checkSing (\strong{optional}) A logical flag. Default is FALSE. If \code{checkSing = TRUE}, then it will check if the design matrix is singular before running conquer.
#' @param tol (\strong{optional}) Tolerance level of the gradient descent algorithm. The iteration will stop when the maximum magnitude of all the elements of the gradient is less than \code{tol}. Default is 1e-04.
#' @param iteMax (\strong{optional}) Maximum number of iterations. Default is 5000.
#' @param stepBounded (\strong{optional}) A logical flag. Default is TRUE. If \code{stepBounded = TRUE}, then the step size of gradient descent is upper bounded by \code{stepMax}. If \code{stepBounded = FALSE}, then the step size is unbounded.
#' @param stepMax (\strong{optional}) Maximum bound for the gradient descent step size. Default is 100.
#' @return An object containing the following items will be returned:
#' \describe{
#' \item{\code{coeff}}{A \eqn{(p + 1)} by \eqn{m} matrix of estimated quantile regression process coefficients, including the intercept. m is the length of \code{tauSeq}.}
#' \item{\code{bandwidth}}{Bandwidth value.}
#' \item{\code{tauSeq}}{The sequence of quantile levels.}
#' \item{\code{kernel}}{The choice of kernel function.}
#' \item{\code{n}}{Sample size.}
#' \item{\code{p}}{Number the covariates.}
#' }
#' @references Barzilai, J. and Borwein, J. M. (1988). Two-point step size gradient methods. IMA J. Numer. Anal., 8, 141–148.
#' @references Fernandes, M., Guerre, E. and Horta, E. (2021). Smoothing quantile regressions. J. Bus. Econ. Statist., 39, 338-357.
#' @references He, X., Pan, X., Tan, K. M., and Zhou, W.-X. (2022+). Smoothed quantile regression for large-scale inference. J. Econometrics, in press.
#' @references Koenker, R. and Bassett, G. (1978). Regression quantiles. Econometrica, 46, 33-50.
#' @seealso See \code{\link{conquer}} for single-index smoothed quantile regression.
#' @examples
#' n = 500; p = 10
#' beta = rep(1, p)
#' X = matrix(rnorm(n * p), n, p)
#' Y = X %*% beta + rt(n, 2)
#'
#' ## Smoothed quantile regression process with Gaussian kernel
#' fit.Gauss = conquer.process(X, Y, tauSeq = seq(0.2, 0.8, by = 0.05), kernel = "Gaussian")
#' beta.hat.Gauss = fit.Gauss$coeff
#'
#' ## Smoothe quantile regression with uniform kernel
#' fit.unif = conquer.process(X, Y, tauSeq = seq(0.2, 0.8, by = 0.05), kernel = "uniform")
#' beta.hat.unif = fit.unif$coeff
#' @export
conquer.process = function(X, Y, tauSeq = seq(0.1, 0.9, by = 0.05), kernel = c("Gaussian", "logistic", "uniform", "parabolic", "triangular"), h = 0.0,
checkSing = FALSE, tol = 0.0001, iteMax = 5000, stepBounded = TRUE, stepMax = 100.0) {
if (nrow(X) != length(Y)) {
stop("Error: the length of Y must be the same as the number of rows of X.")
}
if (ncol(X) >= nrow(X)) {
stop("Error: the number of columns of X cannot exceed the number of rows of X.")
}
if(min(tauSeq) <= 0 || max(tauSeq) >= 1) {
stop("Error: every quantile level must be in (0, 1).")
}
if (min(colSds(X)) == 0) {
stop("Error: at least one column of X is constant.")
}
if (checkSing && rankMatrix(X)[1] < ncol(X)) {
stop("Error: the design matrix X is singular.")
}
kernel = match.arg(kernel)
rst = NULL
if (kernel == "Gaussian") {
if (stepBounded) {
rst = smqrGaussProc(X, Y, tauSeq, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
} else {
rst = smqrGaussProcUbd(X, Y, tauSeq, h, tol = tol, iteMax = iteMax)
}
} else if (kernel == "logistic") {
if (stepBounded) {
rst = smqrLogisticProc(X, Y, tauSeq, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
} else {
rst = smqrLogisticProcUbd(X, Y, tauSeq, h, tol = tol, iteMax = iteMax)
}
} else if (kernel == "uniform") {
if (stepBounded) {
rst = smqrUnifProc(X, Y, tauSeq, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
} else {
rst = smqrUnifProcUbd(X, Y, tauSeq, h, tol = tol, iteMax = iteMax)
}
} else if (kernel == "parabolic") {
if (stepBounded) {
rst = smqrParaProc(X, Y, tauSeq, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
} else {
rst = smqrParaProcUbd(X, Y, tauSeq, h, tol = tol, iteMax = iteMax)
}
} else {
if (stepBounded) {
rst = smqrTrianProc(X, Y, tauSeq, h, tol = tol, iteMax = iteMax, stepMax = stepMax)
} else {
rst = smqrTrianProcUbd(X, Y, tauSeq, h, tol = tol, iteMax = iteMax)
}
}
return (list(coeff = rst$coeff, bandwidth = rst$bandwidth, tauSeq = tauSeq, kernel = kernel, n = nrow(X), p = ncol(X)))
}
#' @title Penalized Convolution-Type Smoothed Quantile Regression
#' @description Fit sparse quantile regression models in high dimensions via regularized conquer methods with "lasso", "elastic-net", "group lasso", "sparse group lasso", "scad" and "mcp" penalties.
#' For "scad" and "mcp", the iteratively reweighted \eqn{\ell_1}-penalized algorithm is complemented with a local adpative majorize-minimize algorithm.
#' @param X An \eqn{n} by \eqn{p} design matrix. Each row is a vector of observations with \eqn{p} covariates.
#' @param Y An \eqn{n}-dimensional response vector.
#' @param lambda (\strong{optional}) Regularization parameter. Can be a scalar or a sequence. If the input is a sequence, the function will sort it in ascending order, and run the regression accordingly. Default is 0.2.
#' @param tau (\strong{optional}) Quantile level (between 0 and 1). Default is 0.5.
#' @param kernel (\strong{optional}) A character string specifying the choice of kernel function. Default is "Gaussian". Choices are "Gaussian", "logistic", "uniform", "parabolic" and "triangular".
#' @param h (\strong{optional}) Bandwidth/smoothing parameter. Default is \eqn{\max\{0.5 * (log(p) / n)^{0.25}, 0.05\}}. The default will be used if the input value is less than or equal to 0.
#' @param penalty (\strong{optional}) A character string specifying the penalty. Default is "lasso" (Tibshirani, 1996). The other options are "elastic" for elastic-net (Zou and Hastie, 2005), "group" for group lasso (Yuan and Lin, 2006), "sparse-group" for sparse group lasso (Simon et al., 2013), "scad" (Fan and Li, 2001) and "mcp" (Zhang, 2010).
#' @param para.elastic (\strong{optional}) The mixing parameter between 0 and 1 (usually noted as \eqn{\alpha}) for elastic-net. The penalty is defined as \eqn{\alpha ||\beta||_1 + (1 - \alpha) ||\beta||_2^2}. Default is 0.5.
#' Setting \code{para.elastic = 1} gives the lasso penalty, and setting \code{para.elastic = 0} yields the ridge penalty. Only specify it when \code{penalty = "elastic"}.
#' @param group (\strong{optional}) A \eqn{p}-dimensional vector specifying group indices. Only specify it if \code{penalty = "group"} or \code{penalty = "sparse-group"}.
#' For example, if \eqn{p = 10}, and we assume the first 3 coefficients belong to the first group, and the last 7 coefficients belong to the second group, then the argument should be \code{group = c(rep(1, 3), rep(2, 7))}. If not specified, then the penalty will be the classical lasso.
#' @param weights (\strong{optional}) A vector specifying groups weights for group Lasso and sparse group Lasso. The length must be equal to the number of groups. If not specified, the default weights are square roots of group sizes.
#' For example , if \code{group = c(rep(1, 3), rep(2, 7))}, then the default weights are \eqn{\sqrt{3}} for the first group, and \eqn{\sqrt{7}} for the second group.
#' @param para.scad (\strong{optional}) The constant parameter for "scad". Default value is 3.7. Only specify it if \code{penalty = "scad"}.
#' @param para.mcp (\strong{optional}) The constant parameter for "mcp". Default value is 3. Only specify it if \code{penalty = "mcp"}.
#' @param epsilon (\strong{optional}) A tolerance level for the stopping rule. The iteration will stop when the maximum magnitude of the change of coefficient updates is less than \code{epsilon}. Default is 0.001.
#' @param iteMax (\strong{optional}) Maximum number of iterations. Default is 500.
#' @param phi0 (\strong{optional}) The initial quadratic coefficient parameter in the local adaptive majorize-minimize algorithm. Default is 0.01.
#' @param gamma (\strong{optional}) The adaptive search parameter (greater than 1) in the local adaptive majorize-minimize algorithm. Default is 1.2.
#' @param iteTight (\strong{optional}) Maximum number of tightening iterations in the iteratively reweighted \eqn{\ell_1}-penalized algorithm. Only specify it if the penalty is scad or mcp. Default is 3.
#' @return An object containing the following items will be returned:
#' \describe{
#' \item{\code{coeff}}{If the input \code{lambda} is a scalar, then \code{coeff} returns a \eqn{(p + 1)} vector of estimated coefficients, including the intercept. If the input \code{lambda} is a sequence, then \code{coeff} returns a \eqn{(p + 1)} by \eqn{nlambda} matrix, where \eqn{nlambda} refers to the length of \code{lambda} sequence.}
#' \item{\code{bandwidth}}{Bandwidth value.}
#' \item{\code{tau}}{Quantile level.}
#' \item{\code{kernel}}{Kernel function.}
#' \item{\code{penalty}}{Penalty type.}
#' \item{\code{lambda}}{Regularization parameter(s).}
#' \item{\code{n}}{Sample size.}
#' \item{\code{p}}{Number of the covariates.}
#' }
#' @references Belloni, A. and Chernozhukov, V. (2011). \eqn{\ell_1} penalized quantile regression in high-dimensional sparse models. Ann. Statist., 39, 82-130.
#' @references Fan, J. and Li, R. (2001). Variable selection via nonconcave regularized likelihood and its oracle properties. J. Amer. Statist. Assoc., 96, 1348-1360.
#' @references Fan, J., Liu, H., Sun, Q. and Zhang, T. (2018). I-LAMM for sparse learning: Simultaneous control of algorithmic complexity and statistical error. Ann. Statist., 46, 814-841.
#' @references Koenker, R. and Bassett, G. (1978). Regression quantiles. Econometrica, 46, 33-50.
#' @references Simon, N., Friedman, J., Hastie, T. and Tibshirani, R. (2013). A sparse-group lasso. J. Comp. Graph. Statist., 22, 231-245.
#' @references Tibshirani, R. (1996). Regression shrinkage and selection via the lasso. J. R. Statist. Soc. Ser. B, 58, 267–288.
#' @references Tan, K. M., Wang, L. and Zhou, W.-X. (2022). High-dimensional quantile regression: convolution smoothing and concave regularization. J. Roy. Statist. Soc. Ser. B, 84, 205-233.
#' @references Yuan, M. and Lin, Y. (2006). Model selection and estimation in regression with grouped variables., J. Roy. Statist. Soc. Ser. B, 68, 49-67.
#' @references Zhang, C.-H. (2010). Nearly unbiased variable selection under minimax concave penalty. Ann. Statist., 38, 894-942.
#' @references Zou, H. and Hastie, T. (2005). Regularization and variable selection via the elastic net. J. R. Statist. Soc. Ser. B, 67, 301-320.
#' @seealso See \code{\link{conquer.cv.reg}} for regularized quantile regression with cross-validation.
#' @examples
#' n = 200; p = 500; s = 10
#' beta = c(rep(1.5, s), rep(0, p - s))
#' X = matrix(rnorm(n * p), n, p)
#' Y = X %*% beta + rt(n, 2)
#'
#' ## Regularized conquer with lasso penalty at tau = 0.7
#' fit.lasso = conquer.reg(X, Y, lambda = 0.05, tau = 0.7, penalty = "lasso")
#' beta.lasso = fit.lasso$coeff
#'
#' ## Regularized conquer with elastic-net penalty at tau = 0.7
#' fit.elastic = conquer.reg(X, Y, lambda = 0.1, tau = 0.7, penalty = "elastic", para.elastic = 0.7)
#' beta.elastic = fit.elastic$coeff
#'
#' ## Regularized conquer with scad penalty at tau = 0.7
#' fit.scad = conquer.reg(X, Y, lambda = 0.13, tau = 0.7, penalty = "scad")
#' beta.scad = fit.scad$coeff
#'
#' ## Regularized conquer with group lasso at tau = 0.7
#' beta = c(rep(1.3, 5), rep(1.5, 5), rep(0, p - s))
#' err = rt(n, 2)
#' Y = X %*% beta + err
#' group = c(rep(1, 5), rep(2, 5), rep(3, p - s))
#' fit.group = conquer.reg(X, Y, lambda = 0.05, tau = 0.7, penalty = "group", group = group)
#' beta.group = fit.group$coeff
#' @export
conquer.reg = function(X, Y, lambda = 0.2, tau = 0.5, kernel = c("Gaussian", "logistic", "uniform", "parabolic", "triangular"), h = 0.0,
penalty = c("lasso", "elastic", "group", "sparse-group", "scad", "mcp"), para.elastic = 0.5, group = NULL, weights = NULL,
para.scad = 3.7, para.mcp = 3.0, epsilon = 0.001, iteMax = 500, phi0 = 0.01, gamma = 1.2, iteTight = 3) {
n = nrow(X)
p = ncol(X)
if (length(Y) != n) {
stop("Error: the length of Y must be the same as the number of rows of X.")
}
if (tau <= 0 || tau >= 1) {
stop("Error: the quantile level tau must be in (0, 1).")
}
if (min(lambda) <= 0) {
stop("Error: lambda must be positive.")
}
if (min(colSds(X)) == 0) {
stop("Error: at least one column of X is constant.")
}
kernel = match.arg(kernel)
penalty = match.arg(penalty)
if (h <= 0.0) {
h = max(0.5 * (log(p) / n)^(0.25), 0.05);
}
rst = NULL
lambda = sort(lambda)
if (penalty == "lasso" || (penalty == "group" && is.null(group)) || (penalty == "sparse-group" && is.null(group))) {
if (kernel == "Gaussian") {
if (length(lambda) == 1) {
rst = conquerGaussLasso(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerGaussLassoSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
}
} else if (kernel == "logistic") {
if (length(lambda) == 1) {
rst = conquerLogisticLasso(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerLogisticLassoSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
}
} else if (kernel == "uniform") {
if (length(lambda) == 1) {
rst = conquerUnifLasso(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerUnifLassoSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
}
} else if (kernel == "parabolic") {
if (length(lambda) == 1) {
rst = conquerParaLasso(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerParaLassoSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
}
} else {
if (length(lambda) == 1) {
rst = conquerTrianLasso(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerTrianLassoSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax)
}
}
} else if (penalty == "elastic") {
if (para.elastic < 0 || para.elastic > 1) {
stop("Error: the elastic net parameter must be in [0, 1].")
}
if (kernel == "Gaussian") {
if (length(lambda) == 1) {
rst = conquerGaussElastic(X, Y, lambda, tau, para.elastic, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerGaussElasticSeq(X, Y, lambda, tau, para.elastic, h, phi0, gamma, epsilon, iteMax)
}
} else if (kernel == "logistic") {
if (length(lambda) == 1) {
rst = conquerLogisticElastic(X, Y, lambda, tau, para.elastic, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerLogisticElasticSeq(X, Y, lambda, tau, para.elastic, h, phi0, gamma, epsilon, iteMax)
}
} else if (kernel == "uniform") {
if (length(lambda) == 1) {
rst = conquerUnifElastic(X, Y, lambda, tau, para.elastic, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerUnifElasticSeq(X, Y, lambda, tau, para.elastic, h, phi0, gamma, epsilon, iteMax)
}
} else if (kernel == "parabolic") {
if (length(lambda) == 1) {
rst = conquerParaElastic(X, Y, lambda, tau, para.elastic, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerParaElasticSeq(X, Y, lambda, tau, para.elastic, h, phi0, gamma, epsilon, iteMax)
}
} else {
if (length(lambda) == 1) {
rst = conquerTrianElastic(X, Y, lambda, tau, para.elastic, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerTrianElasticSeq(X, Y, lambda, tau, para.elastic, h, phi0, gamma, epsilon, iteMax)
}
}
} else if (penalty == "group") {
if (length(group) != p) {
stop("Error: the argument group refers to the group indices, and its length must be the same as the number of columns of X.")
}
G = length(unique(group))
group = c(0, group - 1)
if (!is.null(weights) && length(weights) != G) {
stop("Error: the length of weights must be equal to the number of groups.")
} else if (is.null(weights)) {
weights = sqrt(as.numeric(table(group)))
}
if (kernel == "Gaussian") {
if (length(lambda) == 1) {
rst = conquerGaussGroupLasso(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerGaussGroupLassoSeq(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
}
} else if (kernel == "logistic") {
if (length(lambda) == 1) {
rst = conquerLogisticGroupLasso(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerLogisticGroupLassoSeq(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
}
} else if (kernel == "uniform") {
if (length(lambda) == 1) {
rst = conquerUnifGroupLasso(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerUnifGroupLassoSeq(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
}
} else if (kernel == "parabolic") {
if (length(lambda) == 1) {
rst = conquerParaGroupLasso(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerParaGroupLassoSeq(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
}
} else {
if (length(lambda) == 1) {
rst = conquerTrianGroupLasso(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerTrianGroupLassoSeq(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
}
}
} else if (penalty == "sparse-group") {
if (length(group) != p) {
stop("Error: the argument group refers to the group indices, and its length must be the same as the number of columns of X.")
}
G = length(unique(group))
group = c(0, group - 1)
if (!is.null(weights) && length(weights) != G) {
stop("Error: the length of weights must be equal to the number of groups.")
} else if (is.null(weights)) {
weights = sqrt(as.numeric(table(group)))
}
if (kernel == "Gaussian") {
if (length(lambda) == 1) {
rst = conquerGaussSparseGroupLasso(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerGaussSparseGroupLassoSeq(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
}
} else if (kernel == "logistic") {
if (length(lambda) == 1) {
rst = conquerLogisticSparseGroupLasso(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerLogisticSparseGroupLassoSeq(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
}
} else if (kernel == "uniform") {
if (length(lambda) == 1) {
rst = conquerUnifSparseGroupLasso(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerUnifSparseGroupLassoSeq(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
}
} else if (kernel == "parabolic") {
if (length(lambda) == 1) {
rst = conquerParaSparseGroupLasso(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerParaSparseGroupLassoSeq(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
}
} else {
if (length(lambda) == 1) {
rst = conquerTrianSparseGroupLasso(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
rst = as.numeric(rst)
} else {
rst = conquerTrianSparseGroupLassoSeq(X, Y, lambda, tau, group, weights, G, h, phi0, gamma, epsilon, iteMax)
}
}
} else if (penalty == "scad") {
if (para.scad <= 0) {
stop("Error: the scad parameter must be positive.")
}
if (kernel == "Gaussian") {
if (length(lambda) == 1) {
rst = conquerGaussScad(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
rst = as.numeric(rst)
} else {
rst = conquerGaussScadSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
}
} else if (kernel == "logistic") {
if (length(lambda) == 1) {
rst = conquerLogisticScad(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
rst = as.numeric(rst)
} else {
rst = conquerLogisticScadSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
}
} else if (kernel == "uniform") {
if (length(lambda) == 1) {
rst = conquerUnifScad(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
rst = as.numeric(rst)
} else {
rst = conquerUnifScadSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
}
} else if (kernel == "parabolic") {
if (length(lambda) == 1) {
rst = conquerParaScad(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
rst = as.numeric(rst)
} else {
rst = conquerParaScadSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
}
} else {
if (length(lambda) == 1) {
rst = conquerTrianScad(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
rst = as.numeric(rst)
} else {
rst = conquerTrianScadSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
}
}
} else {
if (para.mcp <= 0) {
stop("Error: the mcp parameter must be positive.")
}
if (kernel == "Gaussian") {
if (length(lambda) == 1) {
rst = conquerGaussMcp(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
rst = as.numeric(rst)
} else {
rst = conquerGaussMcpSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
}
} else if (kernel == "logistic") {
if (length(lambda) == 1) {
rst = conquerLogisticMcp(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
rst = as.numeric(rst)
} else {
rst = conquerLogisticMcpSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
}
} else if (kernel == "uniform") {
if (length(lambda) == 1) {
rst = conquerUnifMcp(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
rst = as.numeric(rst)
} else {
rst = conquerUnifMcpSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
}
} else if (kernel == "parabolic") {
if (length(lambda) == 1) {
rst = conquerParaMcp(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
rst = as.numeric(rst)
} else {
rst = conquerParaMcpSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
}
} else {
if (length(lambda) == 1) {
rst = conquerTrianMcp(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
rst = as.numeric(rst)
} else {
rst = conquerTrianMcpSeq(X, Y, lambda, tau, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
}
}
}
return (list(coeff = rst, bandwidth = h, tau = tau, kernel = kernel, penalty = penalty, lambda = lambda, n = n, p = p))
}
#' @title Cross-Validated Penalized Convolution-Type Smoothed Quantile Regression
#' @description Fit sparse quantile regression models via regularized conquer methods with "lasso", "elastic-net", "group lasso", "sparse group lasso", "scad" and "mcp" penalties. The regularization parameter \eqn{\lambda} is selected via cross-validation.
#' @param X An \eqn{n} by \eqn{p} design matrix. Each row is a vector of observations with \eqn{p} covariates.
#' @param Y An \eqn{n}-dimensional response vector.
#' @param lambdaSeq (\strong{optional}) A sequence of candidate regularization parameters. If unspecified, the sequence will be generated by a simulated pivotal quantity approach proposed in Belloni and Chernozhukov (2011).
#' @param tau (\strong{optional}) Quantile level (between 0 and 1). Default is 0.5.
#' @param kernel (\strong{optional}) A character string specifying the choice of kernel function. Default is "Gaussian". Choices are "Gaussian", "logistic", "uniform", "parabolic" and "triangular".
#' @param h (\strong{optional}) The bandwidth parameter for kernel smoothing. Default is \eqn{\max\{0.5 * (log(p) / n)^{0.25}, 0.05\}}. The default will be used if the input value is less than or equal to 0.
#' @param penalty (\strong{optional}) A character string specifying the penalty. Default is "lasso" (Tibshirani, 1996). The other options are "elastic" for elastic-net (Zou and Hastie, 2005), "group" for group lasso (Yuan and Lin, 2006), "sparse-group" for sparse group lasso (Simon et al., 2013), "scad" (Fan and Li, 2001) and "mcp" (Zhang, 2010).
#' @param kfolds (\strong{optional}) Number of folds for cross-validation. Default is 5.
#' @param numLambda (\strong{optional}) Number of \eqn{\lambda} values for cross-validation if \code{lambdaSeq} is unspeficied. Default is 50.
#' @param para.elastic (\strong{optional}) The mixing parameter between 0 and 1 (usually noted as \eqn{\alpha}) for elastic net. The penalty is defined as \eqn{\alpha ||\beta||_1 + (1 - \alpha) ||\beta||_2^2}. Default is 0.5.
#' Setting \code{para.elastic = 1} gives the lasso penalty, and setting \code{para.elastic = 0} yields the ridge penalty. Only specify it when \code{penalty = "elastic"}.
#' @param group (\strong{optional}) A \eqn{p}-dimensional vector specifying group indices. Only specify it if \code{penalty = "group"} or \code{penalty = "sparse-group"}.
#' For example, if \eqn{p = 10}, and we assume the first 3 coefficients belong to the first group, and the last 7 coefficients belong to the second group, then the argument should be \code{group = c(rep(1, 3), rep(2, 7))}. If not specified, then the penalty will be the classical lasso.
#' @param weights (\strong{optional}) A vector specifying groups weights for group Lasso and sparse group Lasso. The length must be equal to the number of groups. If not specified, the default weights are square roots of group sizes.
#' For example , if \code{group = c(rep(1, 3), rep(2, 7))}, then the default weights are \eqn{\sqrt{3}} for the first group, and \eqn{\sqrt{7}} for the second group.
#' @param para.scad (\strong{optional}) The constant parameter for "scad". Default value is 3.7. Only specify it if \code{penalty = "scad"}.
#' @param para.mcp (\strong{optional}) The constant parameter for "mcp". Default value is 3. Only specify it if \code{penalty = "mcp"}.
#' @param epsilon (\strong{optional}) A tolerance level for the stopping rule. The iteration will stop when the maximum magnitude of the change of coefficient updates is less than \code{epsilon}. Default is 0.001.
#' @param iteMax (\strong{optional}) Maximum number of iterations. Default is 500.
#' @param phi0 (\strong{optional}) The initial quadratic coefficient parameter in the local adaptive majorize-minimize algorithm. Default is 0.01.
#' @param gamma (\strong{optional}) The adaptive search parameter (greater than 1) in the local adaptive majorize-minimize algorithm. Default is 1.2.
#' @param iteTight (\strong{optional}) Maximum number of tightening iterations in the iteratively reweighted \eqn{\ell_1}-penalized algorithm. Only specify it if the penalty is scad or mcp. Default is 3.
#' @return An object containing the following items will be returned:
#' \describe{
#' \item{\code{coeff.min}}{A \eqn{(p + 1)} vector of estimated coefficients including the intercept selected by minimizing the cross-validation errors.}
#' \item{\code{coeff.1se}}{A \eqn{(p + 1)} vector of estimated coefficients including the intercept. The corresponding \eqn{\lambda} is the largest \eqn{\lambda} such that the cross-validation error is within 1 standard error of the minimum.}
#' \item{\code{lambdaSeq}}{The sequence of regularization parameter candidates for cross-validation.}
#' \item{\code{lambda.min}}{Regularization parameter selected by minimizing the cross-validation errors. This is the corresponding \eqn{\lambda} of \code{coeff.min}.}
#' \item{\code{lambda.1se}}{The largest regularization parameter such that the cross-validation error is within 1 standard error of the minimum. This is the corresponding \eqn{\lambda} of \code{coeff.1se}.}
#' \item{\code{deviance}}{Cross-validation errors based on the quantile loss. The length is equal to the length of \code{lambdaSeq}.}
#' \item{\code{deviance.se}}{Estimated standard errors of \code{deviance}. The length is equal to the length of \code{lambdaSeq}.}
#' \item{\code{bandwidth}}{Bandwidth value.}
#' \item{\code{tau}}{Quantile level.}
#' \item{\code{kernel}}{Kernel function.}
#' \item{\code{penalty}}{Penalty type.}
#' \item{\code{n}}{Sample size.}
#' \item{\code{p}}{Number of covariates.}
#' }
#' @references Belloni, A. and Chernozhukov, V. (2011). \eqn{\ell_1} penalized quantile regression in high-dimensional sparse models. Ann. Statist., 39, 82-130.
#' @references Fan, J. and Li, R. (2001). Variable selection via nonconcave regularized likelihood and its oracle properties. J. Amer. Statist. Assoc., 96, 1348-1360.
#' @references Fan, J., Liu, H., Sun, Q. and Zhang, T. (2018). I-LAMM for sparse learning: Simultaneous control of algorithmic complexity and statistical error. Ann. Statist., 46, 814-841.
#' @references Koenker, R. and Bassett, G. (1978). Regression quantiles. Econometrica, 46, 33-50.
#' @references Simon, N., Friedman, J., Hastie, T. and Tibshirani, R. (2013). A sparse-group lasso. J. Comp. Graph. Statist., 22, 231-245.
#' @references Tibshirani, R. (1996). Regression shrinkage and selection via the lasso. J. R. Statist. Soc. Ser. B, 58, 267–288.
#' @references Tan, K. M., Wang, L. and Zhou, W.-X. (2022). High-dimensional quantile regression: convolution smoothing and concave regularization. J. Roy. Statist. Soc. Ser. B, 84, 205-233.
#' @references Yuan, M. and Lin, Y. (2006). Model selection and estimation in regression with grouped variables., J. Roy. Statist. Soc. Ser. B, 68, 49-67.
#' @references Zhang, C.-H. (2010). Nearly unbiased variable selection under minimax concave penalty. Ann. Statist., 38, 894-942.
#' @references Zou, H. and Hastie, T. (2005). Regularization and variable selection via the elastic net. J. R. Statist. Soc. Ser. B, 67, 301-320.
#' @seealso See \code{\link{conquer.reg}} for regularized quantile regression with a prescribed \eqn{lambda}.
#' @examples
#' n = 100; p = 200; s = 5
#' beta = c(rep(1.5, s), rep(0, p - s))
#' X = matrix(rnorm(n * p), n, p)
#' Y = X %*% beta + rt(n, 2)
#'
#' ## Cross-validated regularized conquer with lasso penalty at tau = 0.7
#' fit.lasso = conquer.cv.reg(X, Y, tau = 0.7, penalty = "lasso")
#' beta.lasso = fit.lasso$coeff.min
#'
#' ## Cross-validated regularized conquer with elastic-net penalty at tau = 0.7
#' fit.elastic = conquer.cv.reg(X, Y, tau = 0.7, penalty = "elastic", para.elastic = 0.7)
#' beta.elastic = fit.elastic$coeff.min
#'
#' ## Cross-validated regularized conquer with scad penalty at tau = 0.7
#' fit.scad = conquer.cv.reg(X, Y, tau = 0.7, penalty = "scad")
#' beta.scad = fit.scad$coeff.min
#'
#' ## Regularized conquer with group lasso at tau = 0.7
#' beta = c(rep(1.3, 2), rep(1.5, 3), rep(0, p - s))
#' err = rt(n, 2)
#' Y = X %*% beta + err
#' group = c(rep(1, 2), rep(2, 3), rep(3, p - s))
#' fit.group = conquer.cv.reg(X, Y,tau = 0.7, penalty = "group", group = group)
#' beta.group = fit.group$coeff.min
#' @export
conquer.cv.reg = function(X, Y, lambdaSeq = NULL, tau = 0.5, kernel = c("Gaussian", "logistic", "uniform", "parabolic", "triangular"), h = 0.0,
penalty = c("lasso", "elastic", "group", "sparse-group", "scad", "mcp"), para.elastic = 0.5, group = NULL, weights = NULL,
para.scad = 3.7, para.mcp = 3.0, kfolds = 5, numLambda = 50, epsilon = 0.001, iteMax = 500, phi0 = 0.01, gamma = 1.2, iteTight = 3) {
n = nrow(X)
p = ncol(X)
if (length(Y) != n) {
stop("Error: the length of Y must be the same as the number of rows of X.")
}
if(tau <= 0 || tau >= 1) {
stop("Error: the quantile level tau must be in (0, 1).")
}
if (!is.null(lambdaSeq) && min(lambdaSeq) <= 0) {
stop("Error: all lambda's must be positive.")
}
if (min(colSds(X)) == 0) {
stop("Error: at least one column of X is constant.")
}
kernel = match.arg(kernel)
penalty = match.arg(penalty)
if (h <= 0.0) {
h = max(0.5 * (log(p) / n)^(0.25), 0.05);
}
if (is.null(lambdaSeq)) {
if (numLambda == 1) {
stop("Error: numLambda must be greater than 1 for cross-validation.")
}
nsim = 200
U = matrix(runif(nsim * n), nsim, n)
pivot = tau - (U <= tau)
lambda0 = quantile(rowMaxs(abs(pivot %*% scale(X))), 0.9) / n
lambdaSeq = seq(0.05, 2, length.out = numLambda) * lambda0
} else if (length(lambdaSeq) == 1) {
stop("Error: lambdaSeq must be a sequence. Please use conquer.reg instead for a specific lambda.")
} else {
lambdaSeq = sort(lambdaSeq)
}
folds = sample(rep(1:kfolds, ceiling(n / kfolds)), n)
rst = NULL
if (penalty == "lasso" || (penalty == "group" && is.null(group)) || (penalty == "sparse-group" && is.null(group))) {
if (kernel == "Gaussian") {
rst = cvGaussLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax)
} else if (kernel == "logistic") {
rst = cvLogisticLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax)
} else if (kernel == "uniform") {
rst = cvUnifLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax)
} else if (kernel == "parabolic") {
rst = cvParaLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax)
} else {
rst = cvTrianLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax)
}
} else if (penalty == "elastic") {
if (para.elastic < 0 || para.elastic > 1) {
stop("Error: the elastic net parameter must be in [0, 1].")
}
if (kernel == "Gaussian") {
rst = cvGaussElasticWarm(X, Y, lambdaSeq, folds, tau, para.elastic, kfolds, h, phi0, gamma, epsilon, iteMax)
} else if (kernel == "logistic") {
rst = cvLogisticElasticWarm(X, Y, lambdaSeq, folds, tau, para.elastic, kfolds, h, phi0, gamma, epsilon, iteMax)
} else if (kernel == "uniform") {
rst = cvUnifElasticWarm(X, Y, lambdaSeq, folds, tau, para.elastic, kfolds, h, phi0, gamma, epsilon, iteMax)
} else if (kernel == "parabolic") {
rst = cvParaElasticWarm(X, Y, lambdaSeq, folds, tau, para.elastic, kfolds, h, phi0, gamma, epsilon, iteMax)
} else {
rst = cvTrianElasticWarm(X, Y, lambdaSeq, folds, tau, para.elastic, kfolds, h, phi0, gamma, epsilon, iteMax)
}
} else if (penalty == "group") {
if (length(group) != p) {
stop("Error: the argument group refers to the group indices, and its length must be the same as the number of columns of X.")
}
G = length(unique(group))
group = c(0, group - 1)
if (!is.null(weights) && length(weights) != G) {
stop("Error: the length of weights must be equal to the number of groups.")
} else if (is.null(weights)) {
weights = sqrt(as.numeric(table(group)))
}
if (kernel == "Gaussian") {
rst = cvGaussGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weights, G, h, phi0, gamma, epsilon, iteMax)
} else if (kernel == "logistic") {
rst = cvLogisticGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weights, G, h, phi0, gamma, epsilon, iteMax)
} else if (kernel == "uniform") {
rst = cvUnifGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weights, G, h, phi0, gamma, epsilon, iteMax)
} else if (kernel == "parabolic") {
rst = cvParaGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weights, G, h, phi0, gamma, epsilon, iteMax)
} else {
rst = cvTrianGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weights, G, h, phi0, gamma, epsilon, iteMax)
}
} else if (penalty == "sparse-group") {
if (length(group) != p) {
stop("Error: the argument group refers to the group indices, and its length must be the same as the number of columns of X.")
}
G = length(unique(group))
group = c(0, group - 1)
if (!is.null(weights) && length(weights) != G) {
stop("Error: the length of weights must be equal to the number of groups.")
} else if (is.null(weights)) {
weights = sqrt(as.numeric(table(group)))
}
if (kernel == "Gaussian") {
rst = cvGaussSparseGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weights, G, h, phi0, gamma, epsilon, iteMax)
} else if (kernel == "logistic") {
rst = cvLogisticSparseGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weights, G, h, phi0, gamma, epsilon, iteMax)
} else if (kernel == "uniform") {
rst = cvUnifSparseGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weights, G, h, phi0, gamma, epsilon, iteMax)
} else if (kernel == "parabolic") {
rst = cvParaSparseGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weights, G, h, phi0, gamma, epsilon, iteMax)
} else {
rst = cvTrianSparseGroupLassoWarm(X, Y, lambdaSeq, folds, tau, kfolds, group, weights, G, h, phi0, gamma, epsilon, iteMax)
}
} else if (penalty == "scad") {
if (para.scad <= 0) {
stop("Error: the scad parameter must be positive.")
}
if (kernel == "Gaussian") {
rst = cvGaussScadWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
} else if (kernel == "logistic") {
rst = cvLogisticScadWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
} else if (kernel == "uniform") {
rst = cvUnifScadWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
} else if (kernel == "parabolic") {
rst = cvParaScadWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
} else {
rst = cvTrianScadWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para.scad)
}
} else {
if (para.mcp <= 0) {
stop("Error: the mcp parameter must be positive.")
}
if (kernel == "Gaussian") {
rst = cvGaussMcpWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
} else if (kernel == "logistic") {
rst = cvLogisticMcpWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
} else if (kernel == "uniform") {
rst = cvUnifMcpWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
} else if (kernel == "parabolic") {
rst = cvParaMcpWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
} else {
rst = cvTrianMcpWarm(X, Y, lambdaSeq, folds, tau, kfolds, h, phi0, gamma, epsilon, iteMax, iteTight, para.mcp)
}
}
return (list(coeff.min = as.numeric(rst$coeff), coeff.1se = as.numeric(rst$coeffSe), lambdaSeq = lambdaSeq, lambda.min = rst$lambdaMin,
lambda.1se = rst$lambdaSe, deviance = as.numeric(rst$deviance), deviance.se = as.numeric(rst$devianceSd), bandwidth = h, tau = tau,
kernel = kernel, penalty = penalty, n = n, p = p))
}
conquer/R/conquer-package.R 0000644 0001762 0000144 00000004133 14215203743 015321 0 ustar ligges users #' @docType package
#' @name conquer-package
#' @title Conquer: Convolution-Type Smoothed Quantile Regression
#' @description Estimation and inference for conditional linear quantile regression models using a convolution smoothed approach.
#' In the low-dimensional setting, efficient gradient-based methods are employed for fitting both a single model and a regression process over a quantile range. Normal-based and (multiplier) bootstrap confidence intervals for all slope coefficients are constructed.
#' In high dimensions, the conquer methods complemented with \eqn{\ell_1}-penalization and iteratively reweighted \eqn{\ell_1}-penalization are used to fit sparse models.
#' Commonly used penalities, such as the elastic-net, group lasso and sparse group lasso, are also incorporated to deal with more complex low-dimensional structures.
#' @author Xuming He , Xiaoou Pan , Kean Ming Tan , and Wen-Xin Zhou
#' @references Barzilai, J. and Borwein, J. M. (1988). Two-point step size gradient methods. IMA J. Numer. Anal., 8, 141–148.
#' @references Belloni, A. and Chernozhukov, V. (2011). \eqn{\ell_1} penalized quantile regression in high-dimensional sparse models. Ann. Statist., 39, 82-130.
#' @references Fan, J., Liu, H., Sun, Q. and Zhang, T. (2018). I-LAMM for sparse learning: Simultaneous control of algorithmic complexity and statistical error. Ann. Statist., 46, 814-841.
#' @references Fernandes, M., Guerre, E. and Horta, E. (2021). Smoothing quantile regressions. J. Bus. Econ. Statist., 39, 338-357.
#' @references He, X., Pan, X., Tan, K. M., and Zhou, W.-X. (2022+). Smoothed quantile regression for large-scale inference. J. Econometrics, in press.
#' @references Koenker, R. (2005). Quantile Regression. Cambridge University Press, Cambridge.
#' @references Koenker, R. and Bassett, G. (1978). Regression quantiles. Econometrica, 46, 33-50.
#' @references Tan, K. M., Wang, L. and Zhou, W.-X. (2022). High-dimensional quantile regression: convolution smoothing and concave regularization. J. Roy. Statist. Soc. Ser. B, 84(1), 205-233.
NULL
conquer/MD5 0000644 0001762 0000144 00000002215 14401323342 012232 0 ustar ligges users 38ee3f5a801d3ba6ddeb9d92a97df7b8 *DESCRIPTION
b3b431554910a9201415b792bf0c4fa5 *NAMESPACE
aec49d2f04c59bff4727dea4fd9f0fd7 *R/RcppExports.R
e3a7585aacce394633d9dd7013a10bd0 *R/conquer-package.R
117fcb0051657c459624d6d8bc6d5101 *R/generate_ns.R
5eb45dc17e430e7c1b2558fa673d2f03 *R/smqr.R
8402e96a1461efc8fba7a7f156007df1 *README.md
072cd03166b475cc1e2c9dc574255619 *man/conquer-package.Rd
ce36a5b9a2e52e7351f9429217325102 *man/conquer.Rd
09d053945f58da0e5a1ff734b1a7c708 *man/conquer.cv.reg.Rd
7e4443f63b5b0b10ed7ffd822e2a91a5 *man/conquer.process.Rd
68ef8738e0d80c4ba232d865f64d7769 *man/conquer.reg.Rd
034fd25b16df0b2fd1758a37d8ccb855 *src/Makevars
034fd25b16df0b2fd1758a37d8ccb855 *src/Makevars.win
4d4d10dc8c74ad2aab1e73ad3b1287c8 *src/RcppExports.cpp
35c45448ba6a0447e56bfdcf0a74b417 *src/basicOp.h
4ac8aa2c56c19924f0db7d87c2f30954 *src/defFun.cpp
24dbee1d71b63cdf8c85cdbfd46ff9bf *src/highdGauss.cpp
85232e6ba40e62793880795fab65725c *src/highdLogistic.cpp
d4093639999da0aaa2e8cb29f623979a *src/highdPara.cpp
fdc7bae902ff6e54233525fdc5ecd893 *src/highdTrian.cpp
62ab5332f1181b74a2283b34f7e45448 *src/highdUnif.cpp
b9a6b0943d588e5dc809b030ffb39302 *src/lowd.cpp