dansari <- function(x, m ,n)
{
	.C("dansari", as.integer(length(x)), d = as.double(x), as.integer(m),
	as.integer(n), PACKAGE="ctest")$d
}

toltest <- function(x, scores, m) 
{
    a <- sort(scores*x - round(scores*x))
    upper <- a[1:m]       
    upper <- sum(abs(upper[upper < 0]))
    lower <- a[(length(a) - m):length(a)]
    lower <- sum(abs(lower[lower > 0]))
    max(upper, lower)/x   
}

dperm <- function(x, scores, m, paired = NULL, tol = 0.01, fact = NULL)
{
    if (is.null(x)) stop("Non-numeric argument to mathematical function")
    eq <- equiscores(scores, m, tol, fact)
    cp <- cperm(eq, m, paired)
    RVAL <- rep(0, length(x))
    RVAL[x %in% cp$T ] <- cp$Prob[cp$T %in% x]
    return(RVAL) 
}

pperm <- function(q, scores, m, paired = NULL, tol = 0.01, fact = NULL)
{
    if(is.null(q)) stop("Non-numeric argument to mathematical function")
    eq <- equiscores(scores, m, tol, fact)
    cp <- cperm(eq, m, paired)
    RVAL <- c()
    for (i in q) {
        prob <- cp$Prob[cp$T <= i]
        ifelse(length(prob) >= 1, RVAL <- c(RVAL, sum(prob)),
                                  RVAL <- c(RVAL, 0))
    }
    return(RVAL)
}

pperm2 <- function(q, scores, m, paired = NULL, tol = 0.01, fact = NULL)
{
    if (is.null(q)) stop("Non-numeric argument to mathematical function")
    eq <- equiscores(scores, m, tol, fact)
    cp <- cperm(eq, m, paired)
    paired <- any(c(m == length(scores), paired))
    if (paired) {
	expect <- 1/2*sum(scores)
        if (q <= expect) RVAL <- 2*pperm(q, scores, m, paired, tol, fact)
        else RVAL <- 2*(1 - pperm(q, scores, m, paired, tol, fact) + dperm(q,
                            scores, m, paired, tol, fact))
    } else {
        expect <- m/length(scores)*sum(scores)
        cp$T <- cp$T - expect
        q <- q - expect
        RVAL <- c()
        for (i in q) {
            prob <- c(cp$Prob[cp$T <= ifelse(i > 0, -i, i)],
                    cp$Prob[cp$T >= ifelse(i >= 0, i, -i)]) 
            ifelse(length(prob) >= 1, RVAL <- c(RVAL, sum(prob)),
                    RVAL <- c(RVAL, 0))
        } 
        RVAL <- pmin(1, RVAL)
    }
    return(RVAL)
}

qperm <- function(p, scores, m, paired = NULL, tol = 0.01, fact = NULL)
{
    if (is.null(p)) stop("Non-numeric argument to mathematical function")
    if (any(p < 0) || any(p > 1)) {
        warning("p is not a probability")
        return(NaN)
    }
    eq <- equiscores(scores, m, tol, fact)                          
    cp <- cperm(eq, m, paired)
    cs <- cumsum(cp$Prob)
    RVAL <- c()
    for (i in p) {
        quant <- which(cs < i)
        if (length(quant) == 0) quant <- 0
        RVAL <- c(RVAL, cp$T[max(quant) + 1])
    }
    return(RVAL)
}

rperm <- function(n, scores, m)
    sapply(1:n, dummy <- function(x) sum(sample(scores,m)))

equiscores <- function(scores, m, tol = 0.01, fact=NULL)
{
    if (any(is.null(scores))) 
      stop("Non-numeric argument to mathematical function")
    if (is.null(m)) 
      stop("Non-numeric argument to mathematical function")
    if (m < 1) 
      stop("m less than 1")
    if (m > length(scores)) 
      stop("m greater length(scores)")

    fscore <- scores - floor(scores)
    
    if (all(fscore == 0))
    { 
        # integer valued scores
        fact <- 1
        add <- min(scores) - 1
	scores <- scores - add
    } else {
        if (all(fscore[fscore != 0] == 0.5))
        {
            # midranked scores
            fact <- 2
            scores <- scores*fact
            add <- min(scores) - 1
            scores <- scores - add
        } else {
            # rational or real scores
            ssc <- sort(scores)
            b <- min(ssc[2:length(ssc)] - ssc[1:(length(ssc)-1)])
            if (b > 0) b <- ceiling(1/b) else b <- 100
            if (is.null(fact) || fact < b ) {
                if (toltest(b, scores, m) <= tol)
                    fact <- b
                else {
                    # do not induce more than 20.000 columns
                    maxfact <- min(1000, round(20000/sum(scores -
                                                    min(scores))))   
                    if (maxfact < b)
                        fact <- maxfact
                    else {
                        test <- function(x, tol, sc)
                                ifelse(toltest(x, sc, m) - tol > 0, 1/x, x)
                        fact <- optim(10, test, tol=tol, sc=scores)$par
                        if (fact > maxfact) {
                            fact <- maxfact
                            warning(paste("cannot hold tol, tolerance:",
                                     round(toltest(maxfact, scores, m), 6)))
                        } else fact <- min(fact)
                    }
                }
            } 
            scores <- round(scores * fact)
            add <- min(scores)-1
            scores <- scores - add
        }
    }

    RVAL <- list(scores = scores, fact = fact, add = add)
    class(RVAL) <- "equis"
    return(RVAL)
}


cperm <- function(escores, m, paired = NULL)
{
    if (!(class(escores) == "equis"))
        stop("scores are not of class equis") 

    N <- length(escores$scores)

    prob <- rep(0, max(cumsum(escores$scores)))

    if (is.null(paired))
        paired <- (N == m)
    else 
        paired <- (N == m) && paired  

    if (paired) {
        # paired two sample situation
        prob <- c(0, prob)
        prob <- .C("cpermdist1", prob = as.double(prob),
                   as.integer(escores$scores), as.integer(N))$prob
        t <- which(prob != 0)
        prob <- prob[t]
        # 0 is possible
	t <- t - 1
    } else {
        # independent samples
        col <- sum(sort(escores$scores)[(N + 1 - m):N])
        scores <- rep(1, N)
        prob <- .C("cpermdist2", prob = as.double(prob), as.integer(m),
                as.integer(col), as.integer(scores), as.integer(escores$scores),
                as.integer(N), as.integer(1))$prob
        t <- which(prob != 0)
        prob <- prob[t]
    }
    t <- (t + escores$add*m)/escores$fact
    RVAL <- list(T = t, Prob = prob)
    class(RVAL) <- "cperm"
    return(RVAL)
}
    wilcox.exact <-
function(x, y = NULL, alternative = c("two.sided", "less", "greater"), 
         mu = 0, paired = FALSE, exact = NULL, correct = TRUE,
         conf.int = FALSE, conf.level = 0.95) 
{
    alternative <- match.arg(alternative)
    if(!missing(mu) && ((length(mu) > 1) || !is.finite(mu))) 
        stop("mu must be a single number")
    if(conf.int) {
        if(!((length(conf.level) == 1)
             && is.finite(conf.level)
             && (conf.level > 0)
             && (conf.level < 1)))
            stop("conf.level must be a single number between 0 and 1")
    }
    MIDP <- NULL

    if(!is.null(y)) {
        DNAME <- paste(deparse(substitute(x)), "and",
                       deparse(substitute(y)))
        if(paired) {
            if(length(x) != length(y)) 
                stop("x and y must have the same length")
            OK <- complete.cases(x, y)
            x <- x[OK] - y[OK]
            y <- NULL
        }
        else {
            x <- x[is.finite(x)]
            y <- y[is.finite(y)]
        }
    } else {
        DNAME <- deparse(substitute(x))
        if(paired) 
            stop("y missing for paired test")
        x <- x[is.finite(x)]
    }

    if(length(x) < 1) 
        stop("not enough (finite) x observations")
    CORRECTION <- 0
    if(is.null(y)) {
        METHOD <- "Exact Wilcoxon signed rank test"
        x <- x - mu
        ZEROES <- any(x == 0)
        if(ZEROES) 
            x <- x[x != 0]
        n <- length(x)
        if(is.null(exact)) 
            exact <- (n < 50)
        r <- rank(abs(x))
        STATISTIC <- sum(r[x > 0])
        names(STATISTIC) <- "V"
        TIES <- (length(r) != length(unique(r)))

	# always use pperm! psignrank is as fast as pperm

        if (FALSE) { # if(exact && !TIES && !ZEROES) {
            PVAL <-
                switch(alternative,
                       "two.sided" = {
                           if(STATISTIC > (n * (n + 1) / 4)) 
                               p <- 1 - psignrank(STATISTIC - 1, n)
                           else p <- psignrank(STATISTIC, n)
                           min(2 * p, 1)
                       },
                       "greater" = 1 - psignrank(STATISTIC - 1, n),
                       "less" = psignrank(STATISTIC, n))
            if(conf.int && !is.na(x)) {
                ## Exact confidence intervale for the median in the
                ## one-sample case.  When used with paired values this
                ## gives a confidence interval for mean(x) - mean(y).
                x <- x + mu             # we want a conf.int for the median
                alpha <- 1 - conf.level
                diffs <- outer(x, x, "+")
                diffs <- sort(diffs[!lower.tri(diffs)]) / 2
                cint <-
                    switch(alternative,
                           "two.sided" = {
                               qu <- qsignrank(alpha / 2, n)
                               if(qu == 0) qu <- 1
                               ql <- n*(n+1)/2 - qu
                               uci <- diffs[qu]
                               lci <- diffs[ql+1]
                               c(uci, lci)        
                           },
                           "greater"= {
                               qu <- qsignrank(alpha, n)
                               if(qu == 0) qu <- 1
                               uci <- diffs[qu]
                               c(uci, Inf)
                           },
                           "less"= {
                               qu <- qsignrank(alpha, n)
                               if(qu == 0) qu <- 1
                               ql <- n*(n+1)/2 - qu
                               lci <- diffs[ql+1]
                               c(-Inf, lci)        
                           })
                attr(cint, "conf.level") <- conf.level    
            }
        } else {
            if (exact) {
                PVAL <-
                   switch(alternative,
                          "two.sided" = pperm2(STATISTIC, r, n),
                          "greater" = 1 - pperm(STATISTIC - 1, r, n),
                          "less" = pperm(STATISTIC, r, n))
                MIDP <- dperm(STATISTIC, r, n)
                if(conf.int && !is.na(x)) {
                    ## Exact confidence intervale for the median in the
                    ## one-sample case.  When used with paired values this
                    ## gives a confidence interval for mean(x) - mean(y).
                    x <- x + mu             # we want a conf.int for the median
                    alpha <- 1 - conf.level
                    diffs <- outer(x, x, "+")
                    diffs <- sort(diffs[!lower.tri(diffs)]) / 2
                    w <- cumsum(rep(1, max(cumsum(r))))
                    dup <- which(duplicated(diffs))
                    indx <- 1:length(diffs)
                    indx[dup] <- NA
                    w <- w[!is.na(indx)]
                    diffs <- diffs[!is.na(indx)]
                    cint <-
                        switch(alternative,
                               "two.sided" = {
                                   qu <- qperm(alpha/2, r, n) 
                                   ql <- qperm(1-alpha/2, r, n)
                                   if (qu <= min(w)) uci <- min(diffs)
                                   else uci <- max(diffs[w <= qu])
                                   if (ql >= max(w)) lci <- max(diffs)
                                   else lci <- min(diffs[w > ql])
                                   c(uci, lci)
                               },
                               "greater"= {
                                   qu <- qperm(alpha, r, n) 
                                   if (qu <= min(w)) uci <- min(diffs)
                                   else uci <- max(diffs[w <= qu])
                                   c(uci, Inf)
                               },
                               "less"= {
                                   ql <- qperm(1-alpha, r, n)
                                   if (ql >= max(w)) lci <- max(diffs)
                                   else lci <- min(diffs[w > ql])
                                   c(-Inf, lci)
                         })
                     attr(cint, "conf.level") <- conf.level    
	        wmean <- sum(r)/2
                if(floor(wmean) != wmean)
                    ESTIMATE <- mean(c(diffs[floor(wmean)],
                                       diffs[ceiling(wmean)]))
                else
                    ESTIMATE <- mean(c(diffs[wmean-1], diffs[wmean+1]))

                names(ESTIMATE) <- "(pseudo)median"
                }
            } else {
                NTIES <- table(r)
                z <- STATISTIC - n * (n + 1)/4
                SIGMA <- sqrt(n * (n + 1) * (2 * n + 1) / 24
                              - sum(NTIES^3 - NTIES) / 48)
                if(correct) {
                    CORRECTION <-
                        switch(alternative,
                               "two.sided" = sign(z) * 0.5,
                               "greater" = 0.5,
                               "less" = -0.5)
                    METHOD <- paste(METHOD, "with continuity correction")
                }

                PVAL <- pnorm((z - CORRECTION) / SIGMA)
                if(alternative == "two.sided") 
                    PVAL <- 2 * min(PVAL, 1 - PVAL)
                if(alternative == "greater") 
                    PVAL <- 1 - PVAL

                if(conf.int && !is.na(x)) {
                    ## Asymptotic confidence intervale for the median in the
                    ## one-sample case.  When used with paired values this
                    ## gives a confidence interval for mean(x) - mean(y).
                    ## Algorithm not published, thus better documented here.
                    x <- x + mu
                    alpha <- 1 - conf.level
                    ## These are sample based limits for the median
                    mumin <- min(x)
                    mumax <- max(x)
                    ## wdiff(d, zq) returns the absolute difference between  
                    ## the asymptotic Wilcoxon statistic of x - mu - d and
                    ## the quantile zq.
                    CORRECTION.CI <- 0
                    wdiff <- function(d, zq) {
                        xd <- x - d
                        xd <- xd[xd != 0]
                        nx <- length(xd)
                        dr <- rank(abs(xd))
                        zd <- sum(dr[xd > 0])
                        NTIES.CI <- table(dr)
                        zd <- zd - nx * (nx + 1)/4
                        SIGMA.CI <- sqrt(nx * (nx + 1) * (2 * nx + 1) / 24
                                     - sum(NTIES.CI^3 -  NTIES.CI) / 48)
                        if(correct) {
                            CORRECTION.CI <-
                                switch(alternative,
                                       "two.sided" = sign(z) * 0.5,
                                       "greater" = 0.5,
                                       "less" = -0.5)
                        }
                        zd <- (zd - CORRECTION.CI) / SIGMA.CI
                        zd - zq
                    }
                    ## Here we search the root of the function wdiff on the set
                    ## c(mumin, mumax).
                    ##
                    ## This returns a value from c(mumin, mumax) for which
                    ## the asymptotic Wilcoxon statistic is equal to the
                    ## quantile zq.  This means that the statistic is not
                    ## within the critical region, and that implies that d
                    ## is a confidence limit for the median.
                    ##
                    ## As in the exact case, interchange quantiles.
                    cint <- switch(alternative, "two.sided" = {
                        l <- uniroot(wdiff, c(mumin, mumax), tol=1e-4,
                                     zq=qnorm(alpha/2, lower=FALSE))$root
                        u <- uniroot(wdiff, c(mumin, mumax), tol=1e-4,
                                     zq=qnorm(alpha/2))$root
                        c(l, u)
                    }, "greater"= {
                        l <- uniroot(wdiff, c(mumin, mumax), tol=1e-4,
                                     zq=qnorm(alpha, lower=FALSE))$root
                        c(l, +Inf)
                    }, "less"= {
                        u <- uniroot(wdiff, c(mumin, mumax), tol=1e-4,
                                     zq=qnorm(alpha))$root
                        c(-Inf, u)
                    })
                    attr(cint, "conf.level") <- conf.level    
                    ESTIMATE <- uniroot(wdiff, c(mumin, mumax), tol=1e-4,
                                    zq=0)$root
                    names(ESTIMATE) <- "(pseudo)median"
                 }

#                if(exact && TIES) {
#                warning("Cannot compute exact p-value with ties")
#                if(conf.int)
#                    warning(paste("Cannot compute exact confidence",
#                                  "interval with ties"))
#                }
#                if(exact && ZEROES) {
#                   warning("Cannot compute exact p-value with zeroes")
#                   if(conf.int)
#                       warning(paste("Cannot compute exact confidence",
#                                     "interval with zeroes"))
#                }
            }            
	}
    }
    else {
        if(length(y) < 1) 
            stop("not enough y observations")
        METHOD <- "Exact Wilcoxon rank sum test"
        r <- rank(c(x - mu, y))
        n.x <- length(x)
        n.y <- length(y)
        if(is.null(exact)) 
            exact <- (n.x < 50) && (n.y < 50)
        STATISTIC <- sum(r[seq(along = x)]) - n.x * (n.x + 1) / 2
        names(STATISTIC) <- "W"
        TIES <- (length(r) != length(unique(r)))
        if(exact) {

	    # always use pperm! pperm is not as fast as pwilcox

	    if (FALSE) { # if (!TIES) {
                PVAL <-
                    switch(alternative,
                           "two.sided" = {
                               if(STATISTIC > (n.x * n.y / 2)) 
                                   p <- 1 - pwilcox(STATISTIC - 1, n.x, n.y)
                               else
                                   p <- pwilcox(STATISTIC, n.x, n.y)
                               min(2 * p, 1)
                           },
                           "greater" = 1 - pwilcox(STATISTIC - 1, n.x, n.y), 
                           "less" = pwilcox(STATISTIC, n.x, n.y))
                if(conf.int) {
                    ## Exact confidence interval for the location parameter 
                    ## mean(y) - mean(x) in the two-sample case (cf. the
                    ## one-sample case).
                    alpha <- 1 - conf.level
                    diffs <- sort(outer(y, x, "-"))
                    cint <-
                        switch(alternative,
                               "two.sided" = {
                                   qu <- qwilcox(alpha/2, n.x, n.y)
                                   if(qu == 0) qu <- 1
                                   ql <- n.x*n.y - qu
                                   uci <- diffs[qu]
                                   lci <- diffs[ql + 1]
                                   c(uci, lci)
                               },
                               "greater"= {
                                   qu <- qwilcox(alpha, n.x, n.y)
                                   if(qu == 0) qu <- 1
                                   uci <- diffs[qu]
                                   c(uci, Inf)
                               },
                               "less"= {
                                   qu <- qwilcox(alpha, n.x, n.y)
                                   if(qu == 0 ) qu <- 1
                                   ql <- n.x*n.y - qu
                                   lci <- diffs[ql + 1]
                                   c(-Inf, lci)
                               })
                    attr(cint, "conf.level") <- conf.level    
                }
            } else {
		# now the exact case using Streitberg/Roehmel
                PVAL <-
                    switch(alternative,
                           "two.sided" = pperm2(STATISTIC + n.x*(n.x +1)/2, r, n.x),
                           "greater" = 1 - pperm(STATISTIC - 1 + n.x*(n.x+1)/2, r, n.x), 
                           "less" = pperm(STATISTIC+ n.x*(n.x +1)/2, r, n.x))
                MIDP <- dperm(STATISTIC + n.x*(n.x +1)/2, r, n.x)
		if(conf.int) {
                    ## Exact confidence interval for the location parameter 
                    ## mean(y) - mean(x) in the two-sample case (cf. the
                    ## one-sample case).
                    alpha <- 1 - conf.level
                    diffs <- sort(outer(x, y, "-"))
                    w <- cumsum(rep(1, n.x*n.y))
                    dup <- which(duplicated(diffs))
                    indx <- 1:length(diffs)
                    indx[dup] <- NA
                    w <- w[!is.na(indx)]
                    diffs <- diffs[!is.na(indx)]   
                    cint <-
                        switch(alternative,
                               "two.sided" = {
                                   qu <- qperm(alpha/2, r, n.x) - n.x*(n.x+1)/2
                                   ql <- qperm(1-alpha/2, r, n.x) - n.x*(n.x+1)/2
                                   if (qu <= min(w)) uci <- min(diffs)
                                   else uci <- max(diffs[w <= qu])
                                   if (ql >= max(w)) lci <- max(diffs)
                                   else lci <- min(diffs[w > ql])
                                   c(uci, lci)
                               },
                               "greater"= {
	                           qu <- qperm(alpha, r, n.x) - n.x*(n.x+1)/2
                                   if (qu <= min(w)) uci <- min(diffs)
                                   else uci <- max(diffs[w <= qu])
                                   c(uci, +Inf)
                               },
                               "less"= {
                                   ql <- qperm(1-alpha, r, n.x) - n.x*(n.x+1)/2
                                   if (ql >= max(w)) lci <- max(diffs)
                                   else lci <- min(diffs[w > ql]) 
                                   c(-Inf, lci)
                              })
                     attr(cint, "conf.level") <- conf.level    
                     wmean <- n.x/(n.x+n.y)*sum(r) - n.x*(n.x+1)/2
                     if(floor(wmean) != wmean)
                         ESTIMATE <- mean(c(diffs[floor(wmean)],
                                            diffs[ceiling(wmean)]))
                     else
                         ESTIMATE <- mean(c(diffs[wmean-1], diffs[wmean+1]))
                     names(ESTIMATE) <- "difference in location"
                }
            }
        } else {
            NTIES <- table(r)
            z <- STATISTIC - n.x * n.y / 2
            SIGMA <- sqrt((n.x * n.y / 12) *
                          ((n.x + n.y + 1)
                           - sum(NTIES^3 - NTIES)
                           / ((n.x + n.y) * (n.x + n.y - 1))))
            if(correct) {
                CORRECTION <- switch(alternative,
                                     "two.sided" = sign(z) * 0.5,
                                     "greater" = 0.5,
                                     "less" = -0.5)
                METHOD <- paste(METHOD, "with continuity correction")
            }
            PVAL <- pnorm((z - CORRECTION)/SIGMA)
            if(alternative == "two.sided") 
                PVAL <- 2 * min(PVAL, 1 - PVAL)
            if(alternative == "greater") 
                PVAL <- 1 - PVAL

            if(conf.int) {
                ## Asymptotic confidence interval for the location
                ## parameter mean(x) - mean(y) in the two-sample case
                ## (cf. one-sample case).
                ##
                ## Algorithm not published, for a documentation see the
                ## one-sample case.
                alpha <- 1 - conf.level
                mumin <- min(x) - max(y)
                mumax <- max(x) - min(y)
                CORRECTION.CI <- 0
                wdiff <- function(d, zq) {
                    dr <- rank(c(x - d, y))
                    NTIES.CI <- table(dr)
                    dz <- (sum(dr[seq(along = x)])
                           - n.x * (n.x + 1) / 2 - n.x * n.y / 2)
                    if(correct) {
                        CORRECTION.CI <-
                            switch(alternative,
                                   "two.sided" = sign(dz) * 0.5,
                                   "greater" = 0.5,
                                   "less" = -0.5)        
                    }
                    SIGMA.CI <- sqrt((n.x * n.y / 12) *
                                     ((n.x + n.y + 1)
                                      - sum(NTIES.CI^3 - NTIES.CI)
                                      / ((n.x + n.y) * (n.x + n.y - 1))))
                    dz <- (dz - CORRECTION.CI) / SIGMA.CI
                    dz - zq
                }
                cint <- switch(alternative, "two.sided" = {
                    l <- uniroot(wdiff, c(mumin, mumax), tol=1e-4,
                                  zq=qnorm(alpha/2, lower=FALSE))$root
                    u <- uniroot(wdiff, c(mumin, mumax), tol=1e-4,
                                  zq=qnorm(alpha/2))$root
                    c(l, u)
                }, "greater"= {
                    l <- uniroot(wdiff, c(mumin, mumax), tol=1e-4,
                                  zq=qnorm(alpha, lower=FALSE))$root
                    c(l, +Inf)
                }, "less"= {
                    u <- uniroot(wdiff, c(mumin, mumax), tol=1e-4,
                                  zq=qnorm(alpha))$root
                    c(-Inf, u)
                })
                attr(cint, "conf.level") <- conf.level    
                ESTIMATE <- uniroot(wdiff, c(mumin, mumax), tol=1e-4,
                                    zq=0)$root
                names(ESTIMATE) <- "difference in location"
            }

#            if(exact && TIES) {
#                warning("Cannot compute exact p-value with ties")
#                if(conf.int)
#                    warning(paste("Cannot compute exact confidence",
#                                  "intervals with ties"))
#            }
        }
    }

    if (!is.null(MIDP)) {
        names(MIDP) <- "point prob"
        RVAL <- list(statistic = STATISTIC,
                     parameter = MIDP,
                     p.value = PVAL, 
                     null.value = c(mu = mu),
                     alternative = alternative,
                     method = METHOD, 
                     data.name = DNAME)
    } else {
        RVAL <- list(statistic = STATISTIC,
                     p.value = PVAL, 
                     null.value = c(mu = mu),  
                     alternative = alternative,
                     method = METHOD, 
                     data.name = DNAME)
    }
    if(conf.int) {
        RVAL$conf.int <- cint
        RVAL$estimate <- ESTIMATE
    }
    class(RVAL) <- "htest"
    return(RVAL)
}
.First.lib <- function(lib, pkg) library.dynam("exactRankTests", pkg, lib)

require(ctest)
