Upload 6 files

ExWALD.R

@@ -0,0 +1,307 @@
+#' The Ex-Wald family
+#'
+#' @author Freddy Hernandez, \email{fhernanb@unal.edu.co}
+#'
+#' @description
+#' The function \code{ExWALD()} defines the Ex-wALD distribution, three-parameter
+#' continuous distribution for a \code{gamlss.family} object to be used in 
+#' GAMLSS fitting using the function \code{gamlss()}.
+#'
+#' @param mu.link defines the mu.link, with "log" link as the default for the mu parameter.
+#' @param sigma.link defines the sigma.link, with "log" link as the default for the sigma parameter.
+#' @param nu.link defines the nu.link, with "log" link as the default for the nu parameter.
+#'
+#' @references
+#' Schwarz, W. (2001). The ex-Wald distribution as a descriptive model 
+#' of response times. Behavior Research Methods, 
+#' Instruments, & Computers, 33, 457-469.
+#' 
+#' Heathcote, A. (2004). Fitting Wald and ex-Wald distributions to 
+#' response time data: An example using functions for the S-PLUS package. 
+#' Behavior Research Methods, Instruments, & Computers, 36, 678-694.
+#'
+#' @seealso \link{dExWALD}.
+#'
+#' @details
+#' The Ex-Wald distribution with parameters \eqn{\mu}, \eqn{\sigma} 
+#' and \eqn{\nu} has density given by
+#'
+#' \eqn{f(x |\mu, \sigma, \nu) = \frac{1}{\nu} \exp(\frac{-x}{\nu} + \sigma(\mu-k)) F_W(x|k, \sigma) \, \text{for} \, k \geq 0}
+#'
+#' \eqn{f(x |\mu, \sigma, \nu) = \frac{1}{\nu} \exp\left( \frac{-(\sigma-\mu)^2}{2x} \right) Re \left( w(k^\prime \sqrt{x/2} + \frac{\sigma i}{\sqrt{2x}}) \right)  \, \text{for} \, k < 0}
+#'
+#' where \eqn{k=\sqrt{\mu^2-\frac{2}{\nu}}}, 
+#' \eqn{k^\prime=\sqrt{\frac{2}{\nu}-\mu^2}} and
+#' \eqn{F_W} corresponds to the cumulative function of 
+#' the Wald distribution. 
+#' 
+#' More details about those expressions
+#' can be found on page 680 from Heathcote (2004).
+#'
+#' @returns Returns a gamlss.family object which can be used to fit a 
+#' Ex-WALD distribution in the \code{gamlss()} function.
+#'
+#' @example examples/examples_ExWALD.R
+#'
+#' @importFrom gamlss.dist checklink
+#' @importFrom gamlss rqres.plot
+#' @export
+ExWALD <- function(mu.link="log", 
+                   sigma.link="log", 
+                   nu.link="log") {
+  
+  mstats <- checklink("mu.link", "Ex-Wald",
+                      substitute(mu.link), c("log"))
+  dstats <- checklink("sigma.link", "Ex-Wald",
+                      substitute(sigma.link), c("log"))
+  vstats <- checklink("nu.link", "Ex-Wald",
+                      substitute(nu.link), c("log"))
+  
+  structure(list(family     = c("ExWALD", "Ex-Wald"),
+                 parameters = list(mu=TRUE, sigma=TRUE, nu=TRUE),
+                 nopar      = 3,
+                 type       = "Continuous",
+                 
+                 mu.link    = as.character(substitute(mu.link)),
+                 sigma.link = as.character(substitute(sigma.link)),
+                 nu.link    = as.character(substitute(nu.link)),
+                 
+                 mu.linkfun    = mstats$linkfun,
+                 sigma.linkfun = dstats$linkfun,
+                 nu.linkfun    = vstats$linkfun,
+                 
+                 mu.linkinv    = mstats$linkinv,
+                 sigma.linkinv = dstats$linkinv,
+                 nu.linkinv    = vstats$linkinv,
+                 
+                 mu.dr    = mstats$mu.eta,
+                 sigma.dr = dstats$mu.eta,
+                 nu.dr    = vstats$mu.eta,
+                 
+                 # First derivates
+                 
+                 dldm = function(y, mu, sigma, nu) {
+                   dm <- gamlss::numeric.deriv(dExWALD(y, mu, sigma, nu, log=TRUE),
+                                               theta="mu",
+                                               delta=0.001)
+                   dldm <- as.vector(attr(dm, "gradient"))
+                   dldm
+                 },
+                 
+                 dldd = function(y, mu, sigma, nu) {
+                   dd <- gamlss::numeric.deriv(dExWALD(y, mu, sigma, nu, log=TRUE),
+                                               theta="sigma",
+                                               delta=0.001)
+                   dldd <- as.vector(attr(dd, "gradient"))
+                   dldd
+                 },
+                 
+                 dldv = function(y, mu, sigma, nu) {
+                   dv <- gamlss::numeric.deriv(dExWALD(y, mu, sigma, nu, log=TRUE),
+                                               theta="nu",
+                                               delta=0.001)
+                   dldv <- as.vector(attr(dv, "gradient"))
+                   dldv
+                 },
+
+                 # Second derivates
+                 
+                 d2ldm2 = function(y, mu, sigma, nu) {
+                   dm <- gamlss::numeric.deriv(dExWALD(y, mu, sigma, nu, log=TRUE),
+                                                 theta="mu",
+                                                 delta=0.001)
+                   dldm   <- as.vector(attr(dm, "gradient"))
+                   d2ldm2 <- - dldm*dldm
+                   d2ldm2 <- ifelse(d2ldm2 < -1e-15, d2ldm2, -1e-15)
+                   d2ldm2
+                 },
+                 
+                 d2ldmdd = function(y, mu, sigma, nu) {
+                   dm <- gamlss::numeric.deriv(dExWALD(y, mu, sigma, nu, log=TRUE),
+                                                 theta="mu",
+                                                 delta=0.001)
+                   dldm <- as.vector(attr(dm, "gradient"))
+                   dd   <- gamlss::numeric.deriv(dExWALD(y, mu, sigma, nu, log=TRUE),
+                                                 theta="sigma",
+                                                 delta=0.001)
+                   dldd    <- as.vector(attr(dd, "gradient"))
+                   d2ldmdd <- - dldm*dldd
+                   d2ldmdd <- ifelse(d2ldmdd < -1e-15, d2ldmdd, -1e-15)
+                   d2ldmdd
+                 },
+                 
+                 d2ldmdv = function(y, mu, sigma, nu) {
+                   dm <- gamlss::numeric.deriv(dExWALD(y, mu, sigma, nu, log=TRUE),
+                                                 theta="mu",
+                                                 delta=0.001)
+                   dldm <- as.vector(attr(dm, "gradient"))
+                   dv   <- gamlss::numeric.deriv(dExWALD(y, mu, sigma, nu, log=TRUE),
+                                                 theta="nu",
+                                                 delta=0.001)
+                   dldv    <- as.vector(attr(dv, "gradient"))
+                   d2ldmdv <- - dldm*dldv
+                   d2ldmdv <- ifelse(d2ldmdv < -1e-15, d2ldmdv, -1e-15)
+                   d2ldmdv
+                 },
+                 
+                 d2ldd2  = function(y, mu, sigma, nu) {
+                   dd  <- gamlss::numeric.deriv(dExWALD(y, mu, sigma, nu, log=TRUE),
+                                                 theta="sigma",
+                                                 delta=0.001)
+                   dldd   <- as.vector(attr(dd, "gradient"))
+                   d2ldd2 <- - dldd*dldd
+                   d2ldd2 <- ifelse(d2ldd2 < -1e-15, d2ldd2, -1e-15)
+                   d2ldd2
+                 },
+                 
+                 d2ldddv = function(y, mu, sigma, nu) {
+                   dd <- gamlss::numeric.deriv(dExWALD(y, mu, sigma, nu, log=TRUE),
+                                                 theta="sigma",
+                                                 delta=0.001)
+                   dldd <- as.vector(attr(dd, "gradient"))
+                   dv   <- gamlss::numeric.deriv(dExWALD(y, mu, sigma, nu, log=TRUE),
+                                                 theta="nu",
+                                                 delta=0.001)
+                   dldv    <- as.vector(attr(dv, "gradient"))
+                   d2ldddv <- - dldd*dldv
+                   d2ldddv <- ifelse(d2ldddv < -1e-15, d2ldddv, -1e-15)
+                   d2ldddv
+                 },
+                 
+                 d2ldv2  = function(y, mu, sigma, nu) {
+                   dv   <- gamlss::numeric.deriv(dExWALD(y, mu, sigma, nu, log=TRUE),
+                                                 theta="nu",
+                                                 delta=0.001)
+                   dldv   <- as.vector(attr(dv, "gradient"))
+                   d2ldv2 <- - dldv*dldv
+                   d2ldv2 <- ifelse(d2ldv2 < -1e-15, d2ldv2, -1e-15)
+                   d2ldv2
+                 },
+                 
+                 G.dev.incr = function(y, mu, sigma, nu, ...) -2*dExWALD(y, mu, sigma, nu, log=TRUE),
+                 rqres      = expression(rqres(pfun="pExWALD", type="Continuous", y=y, mu=mu, sigma=sigma, nu=nu)),
+                 
+                 mu.initial    = expression(mu    <- rep(fitexw(y)[1], length(y))),
+                 sigma.initial = expression(sigma <- rep(fitexw(y)[2], length(y))),
+                 nu.initial    = expression(nu    <- rep(fitexw(y)[3], length(y))),
+                 
+                 mu.valid    = function(mu)    all(mu > 0),
+                 sigma.valid = function(sigma) all(sigma > 0),
+                 nu.valid    = function(nu)    all(nu > 0),
+                 
+                 y.valid = function(y) all(y > 0),
+                 
+                 mean     = function(mu, sigma, nu) {nu + sigma/mu}, 
+                 variance = function(mu, sigma, nu) {nu^2 + sigma/mu^3}
+  ),
+  class = c("gamlss.family", "family"))
+}
+#' Auxiliar function for the Ex-Wald distribution
+#' @description This function generates start values.
+#' @param x a value for x.
+#' @param p a value for p.
+#' @return returns a vector with starting values.
+#' @keywords internal
+#' @importFrom stats sd var
+#' @export
+exwstpt <- function(x, p=0.5) {
+  t <- p*sd(x)
+  m <- sqrt((mean(x)-t)/(var(x)-t^2))
+  a <- m*(mean(x)-t)
+  res <- c(m, a, t)
+  return(res)
+}
+#' Auxiliar pwald function for the Ex-Wald distribution
+#' @description This function emulates the pWALD function.
+#' @param w a value for w.
+#' @param m a value for m.
+#' @param a a value for a.
+#' @param s a value for s.
+#' @return returns a vector with cumulative probabilities.
+#' @keywords internal
+#' @export
+pwald <- function(w, m, a, s=0) {
+  w <- w - s; 
+  sqrtw <- sqrt(w); 
+  k1 <- (m*w-a)/sqrtw; 
+  k2 <- (m*w+a)/sqrtw
+  p1 <- exp(2*a*m); 
+  p2 <- pnorm(-k2); 
+  bad <- (p1==Inf) | (p2==0); 
+  p <- p1*p2
+  p[bad] <- (exp(-(k1[bad]^2)/2 - 0.94/(k2[bad]^2))/(k2[bad]*((2*pi)^.5)))
+  p + pnorm(k1)
+}
+#' Auxiliar function to generate random values for Ex-Wald distribution
+#' @description This function generates another form to generate values.
+#' @param x a value for x.
+#' @param y a value for y.
+#' @return returns a vector with values.
+#' @keywords internal
+#' @export
+rew <- function(x, y) {
+  uv <- uandv(y, x)
+  exp(y^2-x^2)*(cos(2*x*y)*(1-uv[,1])+sin(2*x*y)*uv[,2])
+}
+#' Auxiliar den_exw function for the Ex-Wald distribution
+#' @description This function emulates the dExWALD function.
+#' @param r value for r.
+#' @param m value for m.
+#' @param a value for a.
+#' @param t value for t.
+#' @return returns a vector with probabilities.
+#' @keywords internal
+#' @export
+den_exw <- function(r, m, a, t) {
+  k <- (m^2 - (2/t))
+  if (k < 0) {
+    res <- exp(m*a - (a^2)/(2*r) - r*(m^2)/2)*
+      rew(sqrt(-r*k/2), a/sqrt(2*r))/t
+  } else {
+    k <- sqrt(k)
+    res <- pwald(r,k,a)*exp(a*(m-k) - (r/t))/t
+  }
+  return(res)
+}
+#' Auxiliar function to obtain minus loglik for Ex-Wald 
+#' @description This function calculates minus loglik.
+#' @param p a vector with the parameters.
+#' @param x a vector with the random sample.
+#' @return returns the minus loglik.
+#' @keywords internal
+#' @export
+negllexw <- function(p, x) {
+  -sum(log(den_exw(x, p[1], p[2], p[3])))
+}
+#' Auxiliar function for the Ex-Wald distribution
+#' @description This function generates starting values.
+#' @param rt a vector with the random sample.
+#' @param p a value for p.
+#' @param start an optional start vector.
+#' @param scaleit logical value to scale.
+#' @return returns a vector with cumulative probabilities.
+#' @keywords internal
+#' @importFrom stats nlminb
+#' @export
+fitexw <- function(rt, p=0.5,
+                   start=exwstpt(rt, p),
+                   scaleit=TRUE){
+  if (scaleit) 
+    fit <- nlminb(start=start,
+                  lower=c(1e-8, 1e-8, 1),
+                  objective=negllexw,
+                  x=rt,
+                  scale=(1/start),
+                  control=list(eval.max=400, iter.max=300))
+  else 
+    fit <- nlminb(start=start,
+                  lower=c(1e-8, 1e-8, 1),
+                  objective=negllexw,
+                  x=rt,
+                  control=list(eval.max=400, iter.max=300, 
+                               scale.tol=1e-8))
+
+  return(fit$par)
+}
+
+

WALD.R

@@ -0,0 +1,131 @@
+#' The Wald family
+#'
+#' @author Sofia Cuartas García, \email{scuartasg@unal.edu.co}
+#'
+#' @description
+#' The function \code{WALD()} defines the wALD distribution, two-parameter
+#' continuous distribution for a \code{gamlss.family} object to be used in GAMLSS fitting
+#' using the function \code{gamlss()}.
+#'
+#' @param mu.link defines the mu.link, with "log" link as the default for the mu parameter.
+#' @param sigma.link defines the sigma.link, with "log" link as the default for the sigma parameter.
+#'
+#' @references
+#' Heathcote, A. (2004). Fitting Wald and ex-Wald distributions to 
+#' response time data: An example using functions for the S-PLUS package. 
+#' Behavior Research Methods, Instruments, & Computers, 36, 678-694.
+#'
+#' @seealso \link{dWALD}.
+#'
+#' @details
+#' The Wald distribution with parameters \eqn{\mu} and \eqn{sigma} has density given by
+#'
+#' \eqn{\operatorname{f}(x |\mu, \sigma)=\frac{\sigma}{\sqrt{2 \pi x^3}} \exp \left[-\frac{(\sigma-\mu x)^2}{2x}\right ], x>0 }
+#'
+#' @returns Returns a gamlss.family object which can be used to fit a WALD distribution in the \code{gamlss()} function.
+#'
+#' @example examples/examples_WALD.R
+#'
+#' @importFrom gamlss.dist checklink
+#' @importFrom gamlss rqres.plot
+#' @export
+WALD <- function (mu.link="log", sigma.link="log"){
+  mstats <- checklink("mu.link", "WALD", 
+                      substitute(mu.link), 
+                      c("log", "own"))
+  dstats <- checklink("sigma.link", "WALD", 
+                      substitute(sigma.link), 
+                      c("log", "own"))
+  
+  structure(list(family=c("WALD", "Wald"),
+                 parameters=list(mu=TRUE, sigma=TRUE),
+                 nopar=2,
+                 type="Continuous",
+                 
+                 mu.link    = as.character(substitute(mu.link)),
+                 sigma.link = as.character(substitute(sigma.link)),
+                 
+                 mu.linkfun    = mstats$linkfun,
+                 sigma.linkfun = dstats$linkfun,
+                 
+                 mu.linkinv    = mstats$linkinv,
+                 sigma.linkinv = dstats$linkinv,
+                 
+                 mu.dr    = mstats$mu.eta,
+                 sigma.dr = dstats$mu.eta,
+                 
+                 # First derivates
+                 dldm = function(y, mu, sigma) {
+                   dldm <- sigma-mu*y
+                   dldm
+                 },
+                 
+                 dldd = function(y, mu, sigma) {
+                   dldd <- 1/sigma - (sigma-mu*y)/y
+                   dldd
+                 },
+                 
+                 # Second derivates
+                 d2ldm2 = function(y, mu, sigma) {
+                   dm   <- gamlss::numeric.deriv(dWALD(y, mu, sigma, log=TRUE),
+                                                 theta="mu",
+                                                 delta=0.0001)
+                   dldm <- as.vector(attr(dm, "gradient"))
+                   d2ldm2 <- - dldm * dldm
+                   d2ldm2 <- ifelse(d2ldm2 < -1e-15, d2ldm2, -1e-15)
+                   d2ldm2
+                 },
+
+                 d2ldmdd = function(y, mu, sigma) {
+                   dm   <- gamlss::numeric.deriv(dWALD(y, mu, sigma, log=TRUE),
+                                                 theta="mu",
+                                                 delta=0.0001)
+                   dldm <- as.vector(attr(dm, "gradient"))
+                   dd   <- gamlss::numeric.deriv(dWALD(y, mu, sigma, log=TRUE),
+                                                 theta="sigma",
+                                                 delta=0.0001)
+                   dldd <- as.vector(attr(dd, "gradient"))
+                   d2ldmdd <- - dldm * dldd
+                   d2ldmdd <- ifelse(d2ldmdd < -1e-15, d2ldmdd, -1e-15)
+                   d2ldmdd
+                 },
+
+                 d2ldd2  = function(y, mu, sigma) {
+                   dd   <- gamlss::numeric.deriv(dWALD(y, mu, sigma, log=TRUE),
+                                                 theta="sigma",
+                                                 delta=0.0001)
+                   dldd <- as.vector(attr(dd, "gradient"))
+                   d2ldd2 <- - dldd * dldd
+                   d2ldd2 <- ifelse(d2ldd2 < -1e-15, d2ldd2, -1e-15)
+                   d2ldd2
+                 },
+                 
+                 G.dev.incr = function(y, mu, sigma, pw = 1, ...) -2*dWALD(y, mu, sigma, log=TRUE),
+                 rqres      = expression(rqres(pfun="pWALD", type="Continuous", y=y, mu=mu, sigma=sigma)),
+                 
+                 mu.initial    = expression(mu    <- rep(wald_start(y)[1], length(y)) ),
+                 sigma.initial = expression(sigma <- rep(wald_start(y)[2], length(y)) ),
+                 
+                 mu.valid    = function(mu)    all(mu > 0),
+                 sigma.valid = function(sigma) all(sigma > 0),
+                 
+                 y.valid = function(y) all(y > 0),
+                 
+                 mean = function(mu, sigma) sigma/mu,
+                 variance = function(mu, sigma) sigma/(mu^3)
+  ),
+  class=c("gamlss.family", "family"))
+}
+#' Initial values for WALD
+#' @description This function generates initial values for the parameters.
+#' @param y vector with the response variable.
+#' @return returns a vector with starting values.
+#' @keywords internal
+#' @export
+#' @importFrom stats var
+wald_start <- function(y) {
+  mu <- sqrt(mean(y)/var(y))
+  sigma <- mu*mean(y)
+  return(c(mu, sigma))
+}
+

dExWALD.R

@@ -0,0 +1,192 @@
+#' The Ex-Wald distribution
+#'
+#' @author Freddy Hernandez, \email{fhernanb@unal.edu.co}
+#'
+#' @description
+#' These functions define the density, distribution function, quantile
+#' function and random generation for the Ex-Wald distribution
+#' with parameter \eqn{\mu}, \eqn{\sigma} and \eqn{\nu}.
+#'
+#' @param x,q vector of (non-negative integer) quantiles.
+#' @param p vector of probabilities.
+#' @param mu vector of the mu parameter.
+#' @param sigma vector of the sigma parameter.
+#' @param nu vector of the nu parameter.
+#' @param n number of random values to return.
+#' @param log,log.p logical; if TRUE, probabilities p are given as log(p).
+#' @param lower.tail logical; if TRUE (default), probabilities are 
+#' P[X <= x], otherwise, P[X > x].
+#' 
+#' @seealso \link{ExWALD}
+#'
+#' @references
+#' Schwarz, W. (2001). The ex-Wald distribution as a descriptive model 
+#' of response times. Behavior Research Methods, 
+#' Instruments, & Computers, 33, 457-469.
+#' 
+#' Heathcote, A. (2004). Fitting Wald and ex-Wald distributions to 
+#' response time data: An example using functions for the S-PLUS package. 
+#' Behavior Research Methods, Instruments, & Computers, 36, 678-694.
+#'
+#' @details
+#' The Wald distribution with parameters \eqn{\mu}, \eqn{\sigma} 
+#' and \eqn{\nu} has density given by
+#'
+#' \eqn{f(x |\mu, \sigma, \nu) = \frac{1}{\nu} \exp(\frac{-x}{\nu} + \sigma(\mu-k)) F_W(x|k, \sigma) \, \text{for} \, k \geq 0}
+#'
+#' \eqn{f(x |\mu, \sigma, \nu) = \frac{1}{\nu} \exp\left( \frac{-(\sigma-\mu)^2}{2x} \right) Re \left( w(k^\prime \sqrt{x/2} + \frac{\sigma i}{\sqrt{2x}}) \right)  \, \text{for} \, k < 0}
+#'
+#' where \eqn{k=\sqrt{\mu^2-\frac{2}{\nu}}}, 
+#' \eqn{k^\prime=\sqrt{\frac{2}{\nu}-\mu^2}} and
+#' \eqn{F_W} corresponds to the cumulative function of 
+#' the Wald distribution. 
+#' 
+#' More details about those expressions
+#' can be found on page 680 from Heathcote (2004).
+#'
+#' @return
+#' \code{dExWALD} gives the density, \code{pExWALD} gives the distribution
+#' function, \code{qExWALD} gives the quantile function, \code{rExWALD}
+#' generates random deviates.
+#'
+#' @example  examples/examples_dExWALD.R
+#'
+#' @export
+dExWALD <- function(x, mu=1.5, sigma=1.5, nu=2, log=FALSE) {
+  if (any(mu<=0))
+    stop ("mu must be positive")
+  if (any(sigma<=0))
+    stop ("sigma must be positive")
+  if (any(nu<=0))
+    stop ("nu must be positive")
+  
+  # Freddy's code
+  k <- mu^2 - 2/nu
+  if (k < 0) {
+    part1 <- -log(nu) + mu*sigma - sigma^2/(2*x) - x*mu^2/2
+    element1 <- sqrt(-x*k/2)
+    element2 <- sigma/sqrt(2*x)
+    element3 <- ifelse(element1 < 30 & element2 < 25, 
+                       rew(element1, element2), 
+                       0)
+    element3 <- abs(element3)
+    part2 <- log(element3)
+    res <- part1 + part2
+  }
+  else {
+    k <- sqrt(k)
+    part1 <- -log(nu)
+    part2 <- sigma*(mu-k)-x/nu
+    part3 <- pWALD(x, mu=k, sigma=sigma, log.p=TRUE)
+    res <- part1 + part2 + part3  # Expression (3)
+  }
+  
+  if (log)
+    return(res)
+  else
+    return(exp(res))
+}
+# Vectorizing
+dExWALD <- Vectorize(dExWALD)
+#' @export
+#' @rdname dExWALD
+pExWALD <- function(q, mu=1.5, sigma=1.5, nu=2, 
+                    lower.tail = TRUE, log.p = FALSE) {
+  if (any(mu<=0))
+    stop ("mu must be positive")
+  if (any(sigma<=0))
+    stop ("sigma must be positive")
+  if (any(nu<=0))
+    stop ("nu must be positive")
+  
+  cdf <- pWALD(q, mu, sigma) - nu * dExWALD(q, mu, sigma, nu)
+  if (lower.tail == TRUE) {
+    cdf <- cdf
+  }
+  else {
+    cdf <- 1 - cdf
+  }
+  if (log.p == FALSE){
+    cdf <- cdf}
+  else {cdf <- log(cdf)}
+  return(cdf)
+}
+#' @export
+#' @rdname dExWALD
+#' @importFrom stats uniroot
+qExWALD <- function(p, mu=1.5, sigma=1.5, nu=2) {
+  if (any(mu<=0))
+    stop ("mu must be positive")
+  if (any(sigma<=0))
+    stop ("sigma must be positive")
+  if (any(nu<=0))
+    stop ("nu must be positive")
+  
+  # Begin auxiliar function
+  my_aux <- function(x, p, mu, sigma, nu) 
+    pExWALD(x, mu, sigma, nu) - p
+  # End auxiliar function
+  
+  uniroot(my_aux, c(0.001, 10000), tol=0.0001, 
+          mu=mu, sigma=sigma, nu=nu, p=p)$root
+}
+# Vectorizing
+qExWALD <- Vectorize(qExWALD)
+#' @export
+#' @rdname dExWALD
+#' @importFrom stats rexp
+rExWALD <- function(n, mu=1.5, sigma=1.5, nu=2) {
+  if (any(mu<=0))
+    stop ("mu must be positive")
+  if (any(sigma<=0))
+    stop ("sigma must be positive")
+  if (any(nu<=0))
+    stop ("nu must be positive")
+  
+  rWALD(n, mu, sigma) + rexp(n, 1/nu)
+}
+#' Auxiliar function for the Ex-Wald distribution
+#' @description This function is an auxiliar function.
+#' @param x a value for x.
+#' @param y a value for y.
+#' @param block a value.
+#' @param tol is the tolerance.
+#' @param maxseries maximum value for series.
+#' @return returns a vector with starting values.
+#' @keywords internal
+#' @export
+uandv <- function(x, y, firstblock=20, block=0,
+                  tol=.Machine$double.eps^(2/3), maxseries=20) {
+  twoxy <- 2*x*y; xsq <- x^2; iexpxsqpi <- 1/(pi*exp(xsq))
+  sin2xy <- sin(twoxy); cos2xy <- cos(twoxy)
+  nmat <- matrix(rep((1:firstblock), each = length(x)), nrow = length(x))
+  nsqmat <- nmat^2; ny <- nmat*y; twoxcoshny <- 2*x*cosh(ny)
+  nsinhny <- nmat*sinh(ny); nsqfrac <- (exp(-nsqmat/4)/(nsqmat+4*xsq))
+  u <- (2*pnorm(x*sqrt(2))-1)+iexpxsqpi*(((1-cos2xy)/(2*x))+2*
+                                           ((nsqfrac*(2*x-twoxcoshny*cos2xy+nsinhny*sin2xy))%*%rep(1, firstblock)))
+  v <- iexpxsqpi*((sin2xy/(2*x))+2*((nsqfrac*(twoxcoshny*sin2xy+
+                                               nsinhny*cos2xy))%*%rep(1,firstblock)))
+  n <- firstblock; converged <- rep(F, length(x))
+  repeat {
+    if ((block<1)||(n>=maxseries)) break
+    else {
+      if ((n+block)>maxseries) block <- (maxseries-n)
+      nmat <- matrix(rep((n+1):(n+block), each=sum(!converged)),
+                    nrow=sum(!converged))
+      nsq <- nmat^2; ny <- nmat*y[!converged];
+      twoxcoshny <- 2*x[!converged]*cosh(ny); nsinhny <- nmat*sinh(ny)
+      nsqfrac <- (exp(-nsq/4)/(nsq+4*xsq[!converged]))
+      du <- iexpxsqpi[!converged]*((2*nsqfrac*(2*x[!converged]-
+                                                 twoxcoshny*cos2xy[!converged]+nsinhny*sin2xy[!converged]))
+                                   %*%rep(1,block))
+      dv <- iexpxsqpi[!converged]*((2*nsqfrac*(twoxcoshny*sin2xy[!converged]+
+                                                nsinhny*cos2xy[!converged]))%*%rep(1, block))
+      u[!converged] <- u[!converged]+du;
+      v[!converged] <- v[!converged]+dv
+      converged[!converged] <- ((du<tol)&(dv<tol))
+      if (all(converged)) break
+    }
+  }
+  cbind(u,v)
+}
+

dWALD.R

@@ -0,0 +1,116 @@
+#' The Wald distribution
+#'
+#' @author Sofia Cuartas, \email{scuartasg@unal.edu.co}
+#'
+#' @description
+#' These functions define the density, distribution function, quantile
+#' function and random generation for the Wald distribution
+#' with parameter \eqn{\mu} and \eqn{\sigma}.
+#'
+#' @param x,q vector of (non-negative integer) quantiles.
+#' @param p vector of probabilities.
+#' @param mu vector of the mu parameter.
+#' @param sigma vector of the sigma parameter.
+#' @param n number of random values to return.
+#' @param log,log.p logical; if TRUE, probabilities p are given as log(p).
+#' @param lower.tail logical; if TRUE (default), probabilities are 
+#' P[X <= x], otherwise, P[X > x].
+#' 
+#' @seealso \link{WALD}
+#'
+#' @references
+#' Heathcote, A. (2004). Fitting Wald and ex-Wald distributions to 
+#' response time data: An example using functions for the S-PLUS package. 
+#' Behavior Research Methods, Instruments, & Computers, 36, 678-694.
+#'
+#' @seealso \link{WALD}.
+#'
+#' @details
+#' The Wald distribution with parameters \eqn{\mu} and \eqn{\sigma} has density given by
+#'
+#' \eqn{f(x |\mu, \sigma)=\frac{\sigma}{\sqrt{2 \pi x^3}} \exp \left[-\frac{(\sigma-\mu x)^2}{2x}\right ],}
+#' 
+#' for \eqn{x < 0}.
+#'
+#' @return
+#' \code{dWALD} gives the density, \code{pWALD} gives the distribution
+#' function, \code{qWALD} gives the quantile function, \code{rWALD}
+#' generates random deviates.
+#'
+#' @example  examples/examples_dWALD.R
+#'
+#' @export
+dWALD <- function(x, mu, sigma, log=FALSE) {
+  if (any(x <= -1e-15)) stop(paste("x must be positive", "\n", ""))
+  if (any(mu <= 0))     stop(paste("mu must  be positive 0", "\n", ""))
+  if (any(sigma <= 0))  stop(paste("sigma must be positive", "\n", ""))
+  
+  res <- log(sigma) - 0.5*log(2*pi) - 1.5*log(x) - (sigma-mu*x)^2/(2*x)
+  
+  if(log == FALSE)
+    return(exp(res))
+  else
+    return(res)
+}
+#' @export
+#' @rdname dWALD
+#' @importFrom stats pnorm
+pWALD <- function(q, mu , sigma, lower.tail = TRUE, log.p = FALSE){
+  if (any(q <= -1e-15)) stop(paste("q must be positive", "\n", ""))
+  if (any(mu <= 0))     stop(paste("mu must  be positive", "\n", ""))
+  if (any(sigma <= 0))  stop(paste("sigma must be positive", "\n", ""))
+  sqrtq <- sqrt(q)
+  k1 <- (mu*q-sigma)/sqrtq
+  k2 <- (mu*q+sigma)/sqrtq
+  p1 <- exp(2*sigma*mu)
+  p2 <- pnorm(-k2)
+  bad <- (p1==Inf) | (p2==0)
+  p <- p1*p2
+  p[bad] <- (exp(-(k1[bad]^2)/2 - 0.94/(k2[bad]^2))/(k2[bad]*((2*pi)^.5)))
+  cdf <- p + pnorm(k1)
+  if (lower.tail == TRUE) {
+    cdf <- cdf
+  }
+  else {
+    cdf <- 1 - cdf
+  }
+  if (log.p == FALSE){
+    cdf <- cdf}
+  else {cdf <- log(cdf)}
+  return(cdf)
+}
+#' @export
+#' @rdname dWALD
+qWALD <- function(p, mu, sigma, lower.tail=TRUE, log.p=FALSE){
+  if (any(mu <= 0))    stop(paste("mu must  be positive 0", "\n", ""))
+  if (any(sigma <= 0)) stop(paste("sigma must be positive", "\n", ""))
+  
+  if (log.p == TRUE) p <- exp(p)
+  else p <- p
+  if (lower.tail == TRUE) p <- p
+  else p <- 1 - p
+  
+  if (any(p < 0) | any(p > 1))  stop(paste("p must be between 0 and 1", "\n", ""))
+  
+  F.inv <- function(y, mu, sigma, nu) {
+    uniroot(function(x) {pWALD(x,mu,sigma) - y},
+            interval=c(0, 99999))$root
+  }
+  F.inv <- Vectorize(F.inv)
+  F.inv(p, mu, sigma)
+}
+#' @export
+#' @rdname dWALD
+#' @importFrom stats rchisq
+rWALD <- function(n, mu, sigma){
+  if (any(n <= 0))     stop(paste("n must be positive","\n",""))
+  if (any(mu <= 0))    stop(paste("mu must  be positive 0", "\n", ""))
+  if (any(sigma <= 0)) stop(paste("sigma must be positive", "\n", ""))
+  y2 <- rchisq(n, 1)
+  y2onm <- y2/mu
+  u <- runif(n)
+  r1 <- (2*sigma + y2onm - sqrt(y2onm*(4*sigma+y2onm)))/(2*mu)
+  r2 <- (sigma/mu)^2/r1
+  r <- ifelse(u < sigma/(sigma+mu*r1), r1, r2)
+  r
+}

server.R

@@ -0,0 +1,137 @@
+source("dWALD.R")
+source("WALD.R")
+source("dExWALD.R")
+source("ExWALD.R")
+
+library(shiny)
+library(MASS) 
+library(gamlss)
+
+shinyServer(function(input, output) {
+  
+  datos_reactivo <- reactive({
+    req(input$datos)
+    
+    datos_char <- unlist(strsplit(input$datos, ","))
+    datos_num <- as.numeric(trimws(datos_char))
+    datos_num <- datos_num[!is.na(datos_num)]
+    
+    if(length(datos_num) == 0) {
+      return(NULL)
+    } else {
+      return(datos_num)
+    }
+  })
+  
+  output$histograma <- renderPlot({
+    datos <- datos_reactivo()
+    req(datos)
+    
+    dist_sel <- input$dist
+    
+    #par(mfrow=c(2, 1))
+    
+    hist(datos, probability = TRUE, col = "lightblue",
+         main = paste("Histogram and estimated density for", dist_sel),
+         xlab = "x")
+    
+    x_seq <- seq(min(datos), max(datos), length.out = 200)
+    
+    # Estimation y curva según distribución elegida
+    if(dist_sel == "Normal") {
+      
+      fit <- gamlss(datos~1, family=NO)
+      mu    <- coef(fit, what="mu")
+      sigma <- exp(coef(fit, what="sigma"))
+      y <- dNO(x_seq, mu = mu, sigma = sigma)
+      lines(x_seq, y, col = "tomato", lwd=3)
+      legend("topright", bty="n",
+             legend="Estimated density",
+             lwd=3, col="tomato")
+      
+    } else if(dist_sel == "WALD") {
+      # Ajuste con fitdistr
+      fit <- tryCatch({
+        mod <- gamlss(datos~1, family=WALD)
+      }, error = function(e) NULL)
+      
+      if(!is.null(fit)) {
+        mu    <- exp(coef(fit, what="mu"))
+        sigma <- exp(coef(fit, what="sigma"))
+        y <- dWALD(x_seq, mu=mu, sigma=sigma)
+        lines(x_seq, y, col = "tomato", lwd=3)
+      }
+      
+    } else if(dist_sel == "ExWALD") {
+      fit <- tryCatch({
+        fit <- gamlss(datos~1, family=ExWALD)
+      }, error = function(e) NULL)
+      
+      if(!is.null(fit)) {
+        mu    <- exp(coef(fit, what="mu"))
+        sigma <- exp(coef(fit, what="sigma"))
+        nu    <- exp(coef(fit, what="nu"))
+        y <- dExWALD(x_seq, mu=mu, sigma=sigma, nu=nu)
+        lines(x_seq, y, col = "tomato", lwd=3)
+      }
+    }
+    # To plot the residual analysis
+    #plot(fit)
+  })
+  
+  output$parametros <- renderTable({
+    datos <- datos_reactivo()
+    req(datos)
+    
+    dist_sel <- input$dist
+    
+    if(dist_sel == "Normal") {
+      mu <- mean(datos)
+      sigma <- sd(datos)
+      data.frame(
+        Parameter = c("μ", "σ", "Mean", "Standard deviation"),
+        Estimation = c(mu, sigma, mean(datos), sd(datos))
+      )
+      
+    } else if(dist_sel == "WALD") {
+      fit <- tryCatch({
+        mod <- gamlss(datos~1, family=WALD)
+      }, error = function(e) NULL)
+      
+      if(!is.null(fit)) {
+        mu    <- exp(coef(fit, what="mu"))
+        sigma <- exp(coef(fit, what="sigma"))
+        data.frame(
+          Parameter = c("μ", "σ", "Mean", "Standard deviation"),
+          Estimation = c(mu, sigma, mean(datos), sd(datos))
+        )
+      } else {
+        data.frame(
+          Parameter = "Error",
+          Estimation = "We cannot fit WALD"
+        )
+      }
+      
+    } else if(dist_sel == "ExWALD") {
+      fit <- tryCatch({
+        fit <- gamlss(datos~1, family=ExWALD)
+      }, error = function(e) NULL)
+      
+      if(!is.null(fit)) {
+        mu    <- exp(coef(fit, what="mu"))
+        sigma <- exp(coef(fit, what="sigma"))
+        nu    <- exp(coef(fit, what="nu"))
+        data.frame(
+          Parameter = c("μ", "σ", "ν", "Mean", "Standard deviation"),
+          Estimation = c(mu, sigma, nu, mean(datos), sd(datos))
+        )
+      } else {
+        data.frame(
+          Parameter = "Error",
+          Estimation = "We cannot fit ExWALD"
+        )
+      }
+    }
+  })
+  
+})

ui.R

@@ -0,0 +1,38 @@
+library(shiny)
+
+shinyUI(fluidPage(
+  titlePanel("Shiny app to estimate parameters for Reaction Times (RTs)"),
+  
+  sidebarLayout(
+    sidebarPanel(
+      textInput("datos", "Enter numbers separated by commas:", 
+                placeholder = "Example: 1.2, 3.4, 2.1, 5.6, 4.3"),
+      
+      selectInput("dist", "Select the distribution:",
+                  choices = c("Normal", "WALD", "ExWALD"),
+                  selected = "Normal"),
+      br(),
+      p("Example 1"),
+      p("The next random sample was obtained from a N(15, 3),"),
+      p("copy and paste the next numbers:"),
+      p("16.5, 19.8, 11.8, 14.6, 14.2, 5.8, 12.8, 17.5, 22.9, 7.5, 9.4, 
+         14.8, 15.3, 12.9, 12.6, 13.4, 20.2, 16.4, 18.4, 15, 15.1, 18.1, 
+         15.9, 16.5, 15.1, 15, 17, 16.5, 19.9, 11.9, 14.1, 13.1, 12, 15.8, 
+         16.3, 16.1, 13.3, 11.2, 17.8, 17.9, 11.4, 15.6, 10.7, 15.1, 13.3, 
+         16.6, 15.5, 12.2, 14.6, 15.2"),
+      br(),
+      p("Example 3"),
+      p("The next random sample was obtained from a ExWALD(2, 5, 1.2),"),
+      p("copy and paste the next numbers:"),
+      p("2.3, 3.8, 3.1, 3.9, 3.2, 3.8, 2.8, 1.3, 4.2, 2.3, 2.9, 2.6, 
+         3.8, 5, 4.6, 3.5, 9.6, 2.3, 3.9, 3.1, 8.6, 2.2, 5.6, 2.7, 2, 
+         3.5, 5.4, 5.1, 3, 2, 5.1, 4.6, 3.7, 3.6, 2.3, 2.3, 3.6, 1.6, 
+         3.6, 2.9, 3.1, 5.4, 3.2, 2.4, 3.4, 3.7, 4.4, 6.3, 2.9, 3.2")
+    ),
+    
+    mainPanel(
+      plotOutput("histograma"),
+      tableOutput("parametros")
+    )
+  )
+))