rqtest:

In musto101/wilcox_R: What the package does (short line)

Usage

rqtest(x, y, qval = 0.5, nboot = 200, alpha = 0.05, SEED = TRUE, xout = FALSE, outfun = outpro, ...)

Arguments

x
y
qval
nboot
alpha
SEED
xout
outfun
...

Examples

##---- Should be DIRECTLY executable !! ----
##-- ==>  Define data, use random,
##--	or do  help(data=index)  for the standard data sets.

## The function is currently defined as
function (x, y, qval = 0.5, nboot = 200, alpha = 0.05, SEED = TRUE, 
    xout = FALSE, outfun = outpro, ...) 
{
    x <- as.matrix(x)
    if (xout) {
        x <- as.matrix(x)
        flag <- outfun(x, ...)$keep
        x <- x[flag, ]
        y <- y[flag]
    }
    x <- as.matrix(x)
    if (SEED) 
        set.seed(2)
    print("Taking bootstrap samples. Please wait.")
    data <- matrix(sample(length(y), size = length(y) * nboot, 
        replace = TRUE), nrow = nboot)
    bvec <- apply(data, 1, rqtest.sub, x, y, qval = qval)
    p <- ncol(x)
    if (p == 1) 
        stop("Use qregci when p=1")
    n <- length(y)
    np <- p + 1
    bvec <- t(bvec)
    semat <- var(bvec[, 2:np])
    temp <- rqfit(x, y, qval = qval)$coef[2:np]
    temp <- as.matrix(temp)
    test <- t(temp) %*% solve(semat) %*% temp
    test <- test * (n - p)/((n - 1) * p)
    p.value <- 1 - pf(test, p, n - p)
    adjusted.alpha = NULL
    b1 = NULL
    if (n <= 60) {
        if (alpha == 0.1) {
            if (p == 2) {
                b1 <- 0 - 0.001965
                b0 <- 0.2179
            }
            if (p == 3) {
                b1 <- 0 - 0.003
                b0 <- 0.2814
            }
            if (p == 4) {
                b1 <- 0 - 0.0058
                b0 <- 0.4478
            }
            if (p == 5) {
                b1 <- 0 - 0.00896
                b0 <- 0.6373
            }
            if (p >= 6) {
                b1 <- 0 - 0.0112
                b0 <- 0.7699
            }
        }
        if (alpha == 0.05) {
            if (p == 2) {
                b1 <- 0 - 0.001173
                b0 <- 0.1203
            }
            if (p == 3) {
                b1 <- 0 - 0.00223
                b0 <- 0.184
            }
            if (p == 4) {
                b1 <- 0 - 0.00476
                b0 <- 0.3356
            }
            if (p == 5) {
                b1 <- 0 - 0.0063
                b0 <- 0.425
            }
            if (p == 6) {
                b1 <- 0 - 0.00858
                b0 <- 0.5648
            }
        }
        if (alpha == 0.025) {
            if (p == 2) {
                b1 <- 0 - 0.00056
                b0 <- 0.05875
            }
            if (p == 3) {
                b1 <- 0 - 0.00149
                b0 <- 0.1143
            }
            if (p == 4) {
                b1 <- 0 - 0.00396
                b0 <- 0.2624
            }
            if (p == 5) {
                b1 <- 0 - 0.00474
                b0 <- 0.3097
            }
            if (p == 6) {
                b1 <- 0 - 0.0064
                b0 <- 0.4111
            }
        }
        if (alpha == 0.01) {
            if (p == 2) {
                b1 <- 0 - 0.00055
                b0 <- 0.043
            }
            if (p == 3) {
                b1 <- 0 - 0.00044
                b0 <- 0.0364
            }
            if (p == 4) {
                b1 <- 0 - 0.0024
                b0 <- 0.1546
            }
            if (p == 5) {
                b1 <- 0 - 0.00248
                b0 <- 0.159
            }
            if (p == 6) {
                b1 <- 0 - 0.00439
                b0 <- 0.2734
            }
        }
        if (!is.null(b1)) 
            adjusted.alpha <- b1 * n + b0
        adjusted.alpha <- max(alpha, adjusted.alpha)
    }
    list(test.stat = test, p.value = p.value, adjusted.alpha = adjusted.alpha)
  }

musto101/wilcox_R documentation built on May 23, 2019, 10:52 a.m.