CRAN Package Check Results for Package robustloggamma

Last updated on 2019-04-19 18:47:16 CEST.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 1.0-2 14.97 182.60 197.57 ERROR
r-devel-linux-x86_64-debian-gcc 1.0-2 13.63 138.04 151.67 ERROR
r-devel-linux-x86_64-fedora-clang 1.0-2 234.10 ERROR
r-devel-linux-x86_64-fedora-gcc 1.0-2 228.98 ERROR
r-devel-windows-ix86+x86_64 1.0-2 42.00 387.00 429.00 ERROR
r-patched-linux-x86_64 1.0-2 14.17 181.02 195.19 ERROR
r-patched-solaris-x86 1.0-2 356.00 ERROR
r-release-linux-x86_64 1.0-2 12.06 180.93 192.99 OK
r-release-windows-ix86+x86_64 1.0-2 25.00 403.00 428.00 OK
r-release-osx-x86_64 1.0-2 OK
r-oldrel-windows-ix86+x86_64 1.0-2 30.00 408.00 438.00 OK
r-oldrel-osx-x86_64 1.0-2 OK

Check Details

Version: 1.0-2
Check: tests
Result: ERROR
     Running 'MLcens-savedvalues.R' [0s/1s]
     Running 'MLcensreg-savedvalues.R' [2s/3s]
     Running 'MMnpcensreg-savedvalues.R' [1s/1s]
     Running 'QTau-savedvalues.R' [0s/1s]
     Running 'Snpcensreg-savedvalues.R' [1s/1s]
     Running 'TQTau-savedvalues.R' [0s/0s]
     Running 'TWQ-savedvalues.R' [0s/0s]
     Running 'TWQTau-savedvalues.R' [0s/1s]
     Running 'WL-savedvalues.R' [0s/1s]
     Running 'WQTau-savedvalues.R' [0s/1s]
     Running 'loggammacenslmrob.ML.R' [9s/10s]
     Running 'loggammacenslmrob.MM.R' [6s/7s]
     Running 'loggammacenslmrob.S.R' [8s/10s]
     Running 'loggammacenslmrob.oneTML.R' [10s/12s]
     Running 'loggammacenslmrob.oneWL.R' [9s/10s]
     Running 'loggammacensrob.ML.R' [4s/4s]
     Running 'loggammacensrob.TQTatu.R' [4s/4s]
     Running 'loggammacensrob.TWQTatu.R' [5s/6s]
     Running 'loggammacensrob.oneTML.R' [5s/6s]
     Running 'loggammacensrob.oneWL.R' [4s/4s]
     Running 'loggammarob.QTau.R' [3s/3s]
     Running 'loggammarob.WL.R' [4s/4s]
     Running 'loggammarob.WQTau.R' [3s/4s]
     Running 'loggammarob.oneWL.R' [3s/4s]
     Running 'oneTMLemp-savedvalues.R' [0s/1s]
     Running 'oneTMLregemp-savedvalues.R' [2s/2s]
     Running 'oneWL-savedvalues.R' [0s/1s]
     Running 'oneWLemp-savedvalues.R' [0s/1s]
     Running 'oneWLexp-savedvalues.R' [0s/1s]
     Running 'oneWLregemp-savedvalues.R' [2s/3s]
     Running 'sumWL-savedvalues.R' [0s/1s]
     Running 'sumoneWL-savedvalues.R' [0s/0s]
    Running the tests in 'tests/loggammacenslmrob.ML.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + ML <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + ML$call <- NULL
     + dput(ML, file='MLcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MLTest <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + MLTest$call <- NULL
     + ML <- dget(file='MLcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MLTest, ML, tol = 2e-6)
     + )
     + }
     Error: MLTest and ML are not equal:
     Component "mu": Mean relative difference: 1.324353e-05
     Component "coefficients": Mean relative difference: 4.916313e-06
     Component "sigma": Mean relative difference: 4.089281e-06
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in 'tests/loggammacenslmrob.MM.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + MMNP <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + dput(MMNP, file='MMnpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MMNPTest <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + MMNP <- dget(file='MMnpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MMNPTest, MMNP, tol = 2e-6)
     + )
     + }
     Error: MMNPTest and MMNP are not equal:
     Component "coefficients": Mean relative difference: 0.007036949
     Component "scale": Mean relative difference: 0.002941794
     Component "fitted.values": Mean relative difference: 0.005523447
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in 'tests/loggammacenslmrob.S.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + SNP <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + dput(SNP, file='Snpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + SNPTest <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + SNP <- dget(file='Snpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(SNPTest, SNP, tol = 2e-5)
     + )
     + }
     Error: SNPTest and SNP are not equal:
     Component "coefficients": Mean relative difference: 0.05346586
     Component "scale": Mean relative difference: 0.0008444163
     Component "fitted.values": Mean relative difference: 0.07052369
     ....
     Execution halted
    Running the tests in 'tests/loggammacenslmrob.oneTML.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneemp$call <- NULL
     + dput(TMLoneemp, file='oneTMLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneempTest$call <- NULL
     + TMLoneemp <- dget(file='oneTMLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(TMLoneempTest, TMLoneemp, tol = 2e-6)
     + )
     + }
     Error: TMLoneempTest and TMLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.007907289
     Component "mu": Mean relative difference: 0.01296166
     Component "sigma": Mean relative difference: 0.05503404
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in 'tests/loggammacenslmrob.oneWL.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneemp$call <- NULL
     + dput(WLoneemp, file='oneWLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneempTest$call <- NULL
     + WLoneemp <- dget(file='oneWLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(WLoneempTest, WLoneemp, tol = 2e-6)
     + )
     + }
     Error: WLoneempTest and WLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.008262107
     Component "mu": Mean relative difference: 0.02474369
     Component "sigma": Mean relative difference: 0.00240464
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 1.0-2
Check: tests
Result: ERROR
     Running ‘MLcens-savedvalues.R’ [0s/1s]
     Running ‘MLcensreg-savedvalues.R’ [2s/3s]
     Running ‘MMnpcensreg-savedvalues.R’ [1s/2s]
     Running ‘QTau-savedvalues.R’ [0s/1s]
     Running ‘Snpcensreg-savedvalues.R’ [1s/1s]
     Running ‘TQTau-savedvalues.R’ [0s/1s]
     Running ‘TWQ-savedvalues.R’ [0s/1s]
     Running ‘TWQTau-savedvalues.R’ [0s/1s]
     Running ‘WL-savedvalues.R’ [0s/1s]
     Running ‘WQTau-savedvalues.R’ [0s/1s]
     Running ‘loggammacenslmrob.ML.R’ [6s/9s]
     Running ‘loggammacenslmrob.MM.R’ [4s/6s]
     Running ‘loggammacenslmrob.S.R’ [5s/8s]
     Running ‘loggammacenslmrob.oneTML.R’ [7s/9s]
     Running ‘loggammacenslmrob.oneWL.R’ [6s/9s]
     Running ‘loggammacensrob.ML.R’ [3s/4s]
     Running ‘loggammacensrob.TQTatu.R’ [3s/4s]
     Running ‘loggammacensrob.TWQTatu.R’ [4s/6s]
     Running ‘loggammacensrob.oneTML.R’ [4s/5s]
     Running ‘loggammacensrob.oneWL.R’ [3s/4s]
     Running ‘loggammarob.QTau.R’ [2s/3s]
     Running ‘loggammarob.WL.R’ [3s/5s]
     Running ‘loggammarob.WQTau.R’ [2s/4s]
     Running ‘loggammarob.oneWL.R’ [2s/4s]
     Running ‘oneTMLemp-savedvalues.R’ [0s/1s]
     Running ‘oneTMLregemp-savedvalues.R’ [2s/3s]
     Running ‘oneWL-savedvalues.R’ [0s/1s]
     Running ‘oneWLemp-savedvalues.R’ [0s/1s]
     Running ‘oneWLexp-savedvalues.R’ [0s/1s]
     Running ‘oneWLregemp-savedvalues.R’ [2s/3s]
     Running ‘sumWL-savedvalues.R’ [0s/1s]
     Running ‘sumoneWL-savedvalues.R’ [0s/1s]
    Running the tests in ‘tests/loggammacenslmrob.ML.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + ML <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + ML$call <- NULL
     + dput(ML, file='MLcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MLTest <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + MLTest$call <- NULL
     + ML <- dget(file='MLcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MLTest, ML, tol = 2e-6)
     + )
     + }
     Error: MLTest and ML are not equal:
     Component "mu": Mean relative difference: 1.324353e-05
     Component "coefficients": Mean relative difference: 4.916313e-06
     Component "sigma": Mean relative difference: 4.089281e-06
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.MM.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + MMNP <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + dput(MMNP, file='MMnpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MMNPTest <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + MMNP <- dget(file='MMnpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MMNPTest, MMNP, tol = 2e-6)
     + )
     + }
     Error: MMNPTest and MMNP are not equal:
     Component "coefficients": Mean relative difference: 0.007036949
     Component "scale": Mean relative difference: 0.002941794
     Component "fitted.values": Mean relative difference: 0.005523447
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.S.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + SNP <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + dput(SNP, file='Snpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + SNPTest <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + SNP <- dget(file='Snpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(SNPTest, SNP, tol = 2e-5)
     + )
     + }
     Error: SNPTest and SNP are not equal:
     Component "coefficients": Mean relative difference: 0.05346586
     Component "scale": Mean relative difference: 0.0008444163
     Component "fitted.values": Mean relative difference: 0.07052369
     ....
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.oneTML.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneemp$call <- NULL
     + dput(TMLoneemp, file='oneTMLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneempTest$call <- NULL
     + TMLoneemp <- dget(file='oneTMLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(TMLoneempTest, TMLoneemp, tol = 2e-6)
     + )
     + }
     Error: TMLoneempTest and TMLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.007907289
     Component "mu": Mean relative difference: 0.01296166
     Component "sigma": Mean relative difference: 0.05503404
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.oneWL.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneemp$call <- NULL
     + dput(WLoneemp, file='oneWLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneempTest$call <- NULL
     + WLoneemp <- dget(file='oneWLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(WLoneempTest, WLoneemp, tol = 2e-6)
     + )
     + }
     Error: WLoneempTest and WLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.008262107
     Component "mu": Mean relative difference: 0.02474369
     Component "sigma": Mean relative difference: 0.00240464
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 1.0-2
Check: compiled code
Result: NOTE
    File ‘robustloggamma/libs/robustloggamma.so’:
     Found no calls to: ‘R_registerRoutines’, ‘R_useDynamicSymbols’
    
    It is good practice to register native routines and to disable symbol
    search.
    
    See ‘Writing portable packages’ in the ‘Writing R Extensions’ manual.
Flavors: r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc

Version: 1.0-2
Check: tests
Result: ERROR
     Running ‘MLcens-savedvalues.R’
     Running ‘MLcensreg-savedvalues.R’
     Running ‘MMnpcensreg-savedvalues.R’
     Running ‘QTau-savedvalues.R’
     Running ‘Snpcensreg-savedvalues.R’
     Running ‘TQTau-savedvalues.R’
     Running ‘TWQ-savedvalues.R’
     Running ‘TWQTau-savedvalues.R’
     Running ‘WL-savedvalues.R’
     Running ‘WQTau-savedvalues.R’
     Running ‘loggammacenslmrob.ML.R’ [10s/11s]
     Running ‘loggammacenslmrob.MM.R’
     Running ‘loggammacenslmrob.S.R’ [9s/10s]
     Running ‘loggammacenslmrob.oneTML.R’ [11s/12s]
     Running ‘loggammacenslmrob.oneWL.R’ [10s/12s]
     Running ‘loggammacensrob.ML.R’
     Running ‘loggammacensrob.TQTatu.R’
     Running ‘loggammacensrob.TWQTatu.R’
     Running ‘loggammacensrob.oneTML.R’
     Running ‘loggammacensrob.oneWL.R’
     Running ‘loggammarob.QTau.R’
     Running ‘loggammarob.WL.R’
     Running ‘loggammarob.WQTau.R’
     Running ‘loggammarob.oneWL.R’
     Running ‘oneTMLemp-savedvalues.R’
     Running ‘oneTMLregemp-savedvalues.R’
     Running ‘oneWL-savedvalues.R’
     Running ‘oneWLemp-savedvalues.R’
     Running ‘oneWLexp-savedvalues.R’
     Running ‘oneWLregemp-savedvalues.R’
     Running ‘sumWL-savedvalues.R’
     Running ‘sumoneWL-savedvalues.R’
    Running the tests in ‘tests/loggammacenslmrob.ML.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + ML <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + ML$call <- NULL
     + dput(ML, file='MLcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MLTest <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + MLTest$call <- NULL
     + ML <- dget(file='MLcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MLTest, ML, tol = 2e-6)
     + )
     + }
     Error: MLTest and ML are not equal:
     Component "mu": Mean relative difference: 1.324353e-05
     Component "coefficients": Mean relative difference: 4.916313e-06
     Component "sigma": Mean relative difference: 4.089281e-06
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.MM.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + MMNP <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + dput(MMNP, file='MMnpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MMNPTest <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + MMNP <- dget(file='MMnpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MMNPTest, MMNP, tol = 2e-6)
     + )
     + }
     Error: MMNPTest and MMNP are not equal:
     Component "coefficients": Mean relative difference: 0.007036949
     Component "scale": Mean relative difference: 0.002941794
     Component "fitted.values": Mean relative difference: 0.005523447
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.S.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + SNP <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + dput(SNP, file='Snpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + SNPTest <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + SNP <- dget(file='Snpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(SNPTest, SNP, tol = 2e-5)
     + )
     + }
     Error: SNPTest and SNP are not equal:
     Component "coefficients": Mean relative difference: 0.05346586
     Component "scale": Mean relative difference: 0.0008444163
     Component "fitted.values": Mean relative difference: 0.07052369
     ....
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.oneTML.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneemp$call <- NULL
     + dput(TMLoneemp, file='oneTMLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneempTest$call <- NULL
     + TMLoneemp <- dget(file='oneTMLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(TMLoneempTest, TMLoneemp, tol = 2e-6)
     + )
     + }
     Error: TMLoneempTest and TMLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.007907289
     Component "mu": Mean relative difference: 0.01296166
     Component "sigma": Mean relative difference: 0.05503404
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.oneWL.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneemp$call <- NULL
     + dput(WLoneemp, file='oneWLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneempTest$call <- NULL
     + WLoneemp <- dget(file='oneWLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(WLoneempTest, WLoneemp, tol = 2e-6)
     + )
     + }
     Error: WLoneempTest and WLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.008262107
     Component "mu": Mean relative difference: 0.02474369
     Component "sigma": Mean relative difference: 0.00240464
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang

Version: 1.0-2
Check: tests
Result: ERROR
     Running ‘MLcens-savedvalues.R’
     Running ‘MLcensreg-savedvalues.R’
     Running ‘MMnpcensreg-savedvalues.R’
     Running ‘QTau-savedvalues.R’
     Running ‘Snpcensreg-savedvalues.R’
     Running ‘TQTau-savedvalues.R’
     Running ‘TWQ-savedvalues.R’
     Running ‘TWQTau-savedvalues.R’
     Running ‘WL-savedvalues.R’
     Running ‘WQTau-savedvalues.R’
     Running ‘loggammacenslmrob.ML.R’
     Running ‘loggammacenslmrob.MM.R’
     Running ‘loggammacenslmrob.S.R’ [9s/10s]
     Running ‘loggammacenslmrob.oneTML.R’ [11s/12s]
     Running ‘loggammacenslmrob.oneWL.R’ [10s/11s]
     Running ‘loggammacensrob.ML.R’
     Running ‘loggammacensrob.TQTatu.R’
     Running ‘loggammacensrob.TWQTatu.R’
     Running ‘loggammacensrob.oneTML.R’
     Running ‘loggammacensrob.oneWL.R’
     Running ‘loggammarob.QTau.R’
     Running ‘loggammarob.WL.R’
     Running ‘loggammarob.WQTau.R’
     Running ‘loggammarob.oneWL.R’
     Running ‘oneTMLemp-savedvalues.R’
     Running ‘oneTMLregemp-savedvalues.R’
     Running ‘oneWL-savedvalues.R’
     Running ‘oneWLemp-savedvalues.R’
     Running ‘oneWLexp-savedvalues.R’
     Running ‘oneWLregemp-savedvalues.R’
     Running ‘sumWL-savedvalues.R’
     Running ‘sumoneWL-savedvalues.R’
    Running the tests in ‘tests/loggammacenslmrob.ML.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + ML <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + ML$call <- NULL
     + dput(ML, file='MLcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MLTest <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + MLTest$call <- NULL
     + ML <- dget(file='MLcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MLTest, ML, tol = 2e-6)
     + )
     + }
     Error: MLTest and ML are not equal:
     Component "mu": Mean relative difference: 1.324353e-05
     Component "coefficients": Mean relative difference: 4.916313e-06
     Component "sigma": Mean relative difference: 4.089281e-06
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.MM.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + MMNP <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + dput(MMNP, file='MMnpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MMNPTest <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + MMNP <- dget(file='MMnpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MMNPTest, MMNP, tol = 2e-6)
     + )
     + }
     Error: MMNPTest and MMNP are not equal:
     Component "coefficients": Mean relative difference: 0.007036949
     Component "scale": Mean relative difference: 0.002941794
     Component "fitted.values": Mean relative difference: 0.005523447
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.S.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + SNP <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + dput(SNP, file='Snpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + SNPTest <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + SNP <- dget(file='Snpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(SNPTest, SNP, tol = 2e-5)
     + )
     + }
     Error: SNPTest and SNP are not equal:
     Component "coefficients": Mean relative difference: 0.05346586
     Component "scale": Mean relative difference: 0.0008444163
     Component "fitted.values": Mean relative difference: 0.07052369
     ....
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.oneTML.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneemp$call <- NULL
     + dput(TMLoneemp, file='oneTMLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneempTest$call <- NULL
     + TMLoneemp <- dget(file='oneTMLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(TMLoneempTest, TMLoneemp, tol = 2e-6)
     + )
     + }
     Error: TMLoneempTest and TMLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.007907289
     Component "mu": Mean relative difference: 0.01296166
     Component "sigma": Mean relative difference: 0.05503404
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.oneWL.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneemp$call <- NULL
     + dput(WLoneemp, file='oneWLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneempTest$call <- NULL
     + WLoneemp <- dget(file='oneWLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(WLoneempTest, WLoneemp, tol = 2e-6)
     + )
     + }
     Error: WLoneempTest and WLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.008262107
     Component "mu": Mean relative difference: 0.02474369
     Component "sigma": Mean relative difference: 0.00240464
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
Flavor: r-devel-linux-x86_64-fedora-gcc

Version: 1.0-2
Check: running tests for arch ‘i386’
Result: ERROR
     Running 'MLcens-savedvalues.R' [0s]
     Running 'MLcensreg-savedvalues.R' [2s]
     Running 'MMnpcensreg-savedvalues.R' [1s]
     Running 'QTau-savedvalues.R' [0s]
     Running 'Snpcensreg-savedvalues.R' [1s]
     Running 'TQTau-savedvalues.R' [0s]
     Running 'TWQ-savedvalues.R' [0s]
     Running 'TWQTau-savedvalues.R' [0s]
     Running 'WL-savedvalues.R' [0s]
     Running 'WQTau-savedvalues.R' [0s]
     Running 'loggammacenslmrob.ML.R' [10s]
     Running 'loggammacenslmrob.MM.R' [7s]
     Running 'loggammacenslmrob.S.R' [9s]
     Running 'loggammacenslmrob.oneTML.R' [12s]
     Running 'loggammacenslmrob.oneWL.R' [10s]
     Running 'loggammacensrob.ML.R' [5s]
     Running 'loggammacensrob.TQTatu.R' [5s]
     Running 'loggammacensrob.TWQTatu.R' [8s]
     Running 'loggammacensrob.oneTML.R' [7s]
     Running 'loggammacensrob.oneWL.R' [6s]
     Running 'loggammarob.QTau.R' [3s]
     Running 'loggammarob.WL.R' [4s]
     Running 'loggammarob.WQTau.R' [4s]
     Running 'loggammarob.oneWL.R' [4s]
     Running 'oneTMLemp-savedvalues.R' [1s]
     Running 'oneTMLregemp-savedvalues.R' [3s]
     Running 'oneWL-savedvalues.R' [1s]
     Running 'oneWLemp-savedvalues.R' [0s]
     Running 'oneWLexp-savedvalues.R' [0s]
     Running 'oneWLregemp-savedvalues.R' [3s]
     Running 'sumWL-savedvalues.R' [0s]
     Running 'sumoneWL-savedvalues.R' [0s]
    Running the tests in 'tests/loggammacenslmrob.ML.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + ML <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + ML$call <- NULL
     + dput(ML, file='MLcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MLTest <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + MLTest$call <- NULL
     + ML <- dget(file='MLcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MLTest, ML, tol = 2e-6)
     + )
     + }
     Error: MLTest and ML are not equal:
     Component "mu": Mean relative difference: 1.324353e-05
     Component "coefficients": Mean relative difference: 4.916313e-06
     Component "sigma": Mean relative difference: 4.089281e-06
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in 'tests/loggammacenslmrob.MM.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + MMNP <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + dput(MMNP, file='MMnpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MMNPTest <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + MMNP <- dget(file='MMnpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MMNPTest, MMNP, tol = 2e-6)
     + )
     + }
     Error: MMNPTest and MMNP are not equal:
     Component "coefficients": Mean relative difference: 0.007036949
     Component "scale": Mean relative difference: 0.002941794
     Component "fitted.values": Mean relative difference: 0.005523447
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in 'tests/loggammacenslmrob.S.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + SNP <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + dput(SNP, file='Snpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + SNPTest <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + SNP <- dget(file='Snpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(SNPTest, SNP, tol = 2e-5)
     + )
     + }
     Error: SNPTest and SNP are not equal:
     Component "coefficients": Mean relative difference: 0.05346586
     Component "scale": Mean relative difference: 0.0008444163
     Component "fitted.values": Mean relative difference: 0.07052369
     ....
     Execution halted
    Running the tests in 'tests/loggammacenslmrob.oneTML.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneemp$call <- NULL
     + dput(TMLoneemp, file='oneTMLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneempTest$call <- NULL
     + TMLoneemp <- dget(file='oneTMLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(TMLoneempTest, TMLoneemp, tol = 2e-6)
     + )
     + }
     Error: TMLoneempTest and TMLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.007907289
     Component "mu": Mean relative difference: 0.01296166
     Component "sigma": Mean relative difference: 0.05503404
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in 'tests/loggammacenslmrob.oneWL.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneemp$call <- NULL
     + dput(WLoneemp, file='oneWLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneempTest$call <- NULL
     + WLoneemp <- dget(file='oneWLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(WLoneempTest, WLoneemp, tol = 2e-6)
     + )
     + }
     Error: WLoneempTest and WLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.008262107
     Component "mu": Mean relative difference: 0.02474369
     Component "sigma": Mean relative difference: 0.00240464
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
Flavor: r-devel-windows-ix86+x86_64

Version: 1.0-2
Check: running tests for arch ‘x64’
Result: ERROR
     Running 'MLcens-savedvalues.R' [0s]
     Running 'MLcensreg-savedvalues.R' [2s]
     Running 'MMnpcensreg-savedvalues.R' [1s]
     Running 'QTau-savedvalues.R' [0s]
     Running 'Snpcensreg-savedvalues.R' [1s]
     Running 'TQTau-savedvalues.R' [0s]
     Running 'TWQ-savedvalues.R' [1s]
     Running 'TWQTau-savedvalues.R' [1s]
     Running 'WL-savedvalues.R' [1s]
     Running 'WQTau-savedvalues.R' [1s]
     Running 'loggammacenslmrob.ML.R' [10s]
     Running 'loggammacenslmrob.MM.R' [8s]
     Running 'loggammacenslmrob.S.R' [10s]
     Running 'loggammacenslmrob.oneTML.R' [12s]
     Running 'loggammacenslmrob.oneWL.R' [10s]
     Running 'loggammacensrob.ML.R' [5s]
     Running 'loggammacensrob.TQTatu.R' [4s]
     Running 'loggammacensrob.TWQTatu.R' [6s]
     Running 'loggammacensrob.oneTML.R' [6s]
     Running 'loggammacensrob.oneWL.R' [5s]
     Running 'loggammarob.QTau.R' [4s]
     Running 'loggammarob.WL.R' [4s]
     Running 'loggammarob.WQTau.R' [4s]
     Running 'loggammarob.oneWL.R' [4s]
     Running 'oneTMLemp-savedvalues.R' [0s]
     Running 'oneTMLregemp-savedvalues.R' [3s]
     Running 'oneWL-savedvalues.R' [1s]
     Running 'oneWLemp-savedvalues.R' [1s]
     Running 'oneWLexp-savedvalues.R' [1s]
     Running 'oneWLregemp-savedvalues.R' [3s]
     Running 'sumWL-savedvalues.R' [0s]
     Running 'sumoneWL-savedvalues.R' [0s]
    Running the tests in 'tests/loggammacenslmrob.ML.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + ML <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + ML$call <- NULL
     + dput(ML, file='MLcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MLTest <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + MLTest$call <- NULL
     + ML <- dget(file='MLcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MLTest, ML, tol = 2e-6)
     + )
     + }
     Error: MLTest and ML are not equal:
     Component "mu": Mean relative difference: 1.324353e-05
     Component "coefficients": Mean relative difference: 4.916313e-06
     Component "sigma": Mean relative difference: 4.089281e-06
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in 'tests/loggammacenslmrob.MM.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + MMNP <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + dput(MMNP, file='MMnpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MMNPTest <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + MMNP <- dget(file='MMnpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MMNPTest, MMNP, tol = 2e-6)
     + )
     + }
     Error: MMNPTest and MMNP are not equal:
     Component "coefficients": Mean relative difference: 0.007036949
     Component "scale": Mean relative difference: 0.002941794
     Component "fitted.values": Mean relative difference: 0.005523447
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in 'tests/loggammacenslmrob.S.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + SNP <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + dput(SNP, file='Snpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + SNPTest <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + SNP <- dget(file='Snpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(SNPTest, SNP, tol = 2e-5)
     + )
     + }
     Error: SNPTest and SNP are not equal:
     Component "coefficients": Mean relative difference: 0.05346586
     Component "scale": Mean relative difference: 0.0008444163
     Component "fitted.values": Mean relative difference: 0.07052369
     ....
     Execution halted
    Running the tests in 'tests/loggammacenslmrob.oneTML.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneemp$call <- NULL
     + dput(TMLoneemp, file='oneTMLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneempTest$call <- NULL
     + TMLoneemp <- dget(file='oneTMLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(TMLoneempTest, TMLoneemp, tol = 2e-6)
     + )
     + }
     Error: TMLoneempTest and TMLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.007907289
     Component "mu": Mean relative difference: 0.01296166
     Component "sigma": Mean relative difference: 0.05503404
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in 'tests/loggammacenslmrob.oneWL.R' failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneemp$call <- NULL
     + dput(WLoneemp, file='oneWLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneempTest$call <- NULL
     + WLoneemp <- dget(file='oneWLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(WLoneempTest, WLoneemp, tol = 2e-6)
     + )
     + }
     Error: WLoneempTest and WLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.008262107
     Component "mu": Mean relative difference: 0.02474369
     Component "sigma": Mean relative difference: 0.00240464
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
Flavor: r-devel-windows-ix86+x86_64

Version: 1.0-2
Check: tests
Result: ERROR
     Running ‘MLcens-savedvalues.R’ [0s/1s]
     Running ‘MLcensreg-savedvalues.R’ [2s/3s]
     Running ‘MMnpcensreg-savedvalues.R’ [1s/1s]
     Running ‘QTau-savedvalues.R’ [0s/0s]
     Running ‘Snpcensreg-savedvalues.R’ [1s/1s]
     Running ‘TQTau-savedvalues.R’ [0s/0s]
     Running ‘TWQ-savedvalues.R’ [0s/0s]
     Running ‘TWQTau-savedvalues.R’ [0s/1s]
     Running ‘WL-savedvalues.R’ [0s/1s]
     Running ‘WQTau-savedvalues.R’ [0s/1s]
     Running ‘loggammacenslmrob.ML.R’ [8s/9s]
     Running ‘loggammacenslmrob.MM.R’ [6s/7s]
     Running ‘loggammacenslmrob.S.R’ [8s/8s]
     Running ‘loggammacenslmrob.oneTML.R’ [10s/10s]
     Running ‘loggammacenslmrob.oneWL.R’ [8s/9s]
     Running ‘loggammacensrob.ML.R’ [4s/4s]
     Running ‘loggammacensrob.TQTatu.R’ [3s/4s]
     Running ‘loggammacensrob.TWQTatu.R’ [5s/5s]
     Running ‘loggammacensrob.oneTML.R’ [5s/5s]
     Running ‘loggammacensrob.oneWL.R’ [4s/4s]
     Running ‘loggammarob.QTau.R’ [3s/3s]
     Running ‘loggammarob.WL.R’ [3s/4s]
     Running ‘loggammarob.WQTau.R’ [3s/3s]
     Running ‘loggammarob.oneWL.R’ [3s/4s]
     Running ‘oneTMLemp-savedvalues.R’ [0s/0s]
     Running ‘oneTMLregemp-savedvalues.R’ [2s/3s]
     Running ‘oneWL-savedvalues.R’ [0s/1s]
     Running ‘oneWLemp-savedvalues.R’ [0s/1s]
     Running ‘oneWLexp-savedvalues.R’ [0s/0s]
     Running ‘oneWLregemp-savedvalues.R’ [3s/3s]
     Running ‘sumWL-savedvalues.R’ [0s/1s]
     Running ‘sumoneWL-savedvalues.R’ [0s/1s]
    Running the tests in ‘tests/loggammacenslmrob.ML.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + ML <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + ML$call <- NULL
     + dput(ML, file='MLcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MLTest <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + MLTest$call <- NULL
     + ML <- dget(file='MLcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MLTest, ML, tol = 2e-6)
     + )
     + }
     Error: MLTest and ML are not equal:
     Component "mu": Mean relative difference: 1.324353e-05
     Component "coefficients": Mean relative difference: 4.916313e-06
     Component "sigma": Mean relative difference: 4.089281e-06
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.MM.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + MMNP <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + dput(MMNP, file='MMnpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MMNPTest <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + MMNP <- dget(file='MMnpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MMNPTest, MMNP, tol = 2e-6)
     + )
     + }
     Error: MMNPTest and MMNP are not equal:
     Component "coefficients": Mean relative difference: 0.007036949
     Component "scale": Mean relative difference: 0.002941794
     Component "fitted.values": Mean relative difference: 0.005523447
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.S.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + SNP <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + dput(SNP, file='Snpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + SNPTest <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + SNP <- dget(file='Snpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(SNPTest, SNP, tol = 2e-5)
     + )
     + }
     Error: SNPTest and SNP are not equal:
     Component "coefficients": Mean relative difference: 0.05346586
     Component "scale": Mean relative difference: 0.0008444163
     Component "fitted.values": Mean relative difference: 0.07052369
     ....
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.oneTML.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneemp$call <- NULL
     + dput(TMLoneemp, file='oneTMLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneempTest$call <- NULL
     + TMLoneemp <- dget(file='oneTMLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(TMLoneempTest, TMLoneemp, tol = 2e-6)
     + )
     + }
     Error: TMLoneempTest and TMLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.007907289
     Component "mu": Mean relative difference: 0.01296166
     Component "sigma": Mean relative difference: 0.05503404
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.oneWL.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneemp$call <- NULL
     + dput(WLoneemp, file='oneWLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneempTest$call <- NULL
     + WLoneemp <- dget(file='oneWLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(WLoneempTest, WLoneemp, tol = 2e-6)
     + )
     + }
     Error: WLoneempTest and WLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.008262107
     Component "mu": Mean relative difference: 0.02474369
     Component "sigma": Mean relative difference: 0.00240464
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
Flavor: r-patched-linux-x86_64

Version: 1.0-2
Check: tests
Result: ERROR
     Running ‘MLcens-savedvalues.R’
     Running ‘MLcensreg-savedvalues.R’
     Running ‘MMnpcensreg-savedvalues.R’
     Running ‘QTau-savedvalues.R’
     Running ‘Snpcensreg-savedvalues.R’
     Running ‘TQTau-savedvalues.R’
     Running ‘TWQ-savedvalues.R’
     Running ‘TWQTau-savedvalues.R’
     Running ‘WL-savedvalues.R’
     Running ‘WQTau-savedvalues.R’
     Running ‘loggammacenslmrob.ML.R’ [17s/20s]
     Running ‘loggammacenslmrob.MM.R’ [12s/13s]
     Running ‘loggammacenslmrob.S.R’ [14s/18s]
     Running ‘loggammacenslmrob.oneTML.R’ [19s/25s]
     Running ‘loggammacenslmrob.oneWL.R’ [18s/22s]
     Running ‘loggammacensrob.ML.R’ [9s/13s]
     Running ‘loggammacensrob.TQTatu.R’ [9s/10s]
     Running ‘loggammacensrob.TWQTatu.R’ [13s/16s]
     Running ‘loggammacensrob.oneTML.R’ [11s/13s]
     Running ‘loggammacensrob.oneWL.R’ [9s/14s]
     Running ‘loggammarob.QTau.R’
     Running ‘loggammarob.WL.R’
     Running ‘loggammarob.WQTau.R’
     Running ‘loggammarob.oneWL.R’
     Running ‘oneTMLemp-savedvalues.R’
     Running ‘oneTMLregemp-savedvalues.R’
     Running ‘oneWL-savedvalues.R’
     Running ‘oneWLemp-savedvalues.R’
     Running ‘oneWLexp-savedvalues.R’
     Running ‘oneWLregemp-savedvalues.R’
     Running ‘sumWL-savedvalues.R’
     Running ‘sumoneWL-savedvalues.R’
    Running the tests in ‘tests/loggammacenslmrob.ML.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + ML <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + ML$call <- NULL
     + dput(ML, file='MLcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MLTest <- loggammacenslmrob(y~X, delta=delta, method="ML")
     + MLTest$call <- NULL
     + ML <- dget(file='MLcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MLTest, ML, tol = 2e-6)
     + )
     + }
     Error: MLTest and ML are not equal:
     Component "mu": Mean relative difference: 1.324353e-05
     Component "coefficients": Mean relative difference: 4.916313e-06
     Component "sigma": Mean relative difference: 4.089281e-06
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.MM.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + MMNP <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + dput(MMNP, file='MMnpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + MMNPTest <- robustloggamma:::loggammacenslmrob.MM(IX,y,delta,control=robustloggamma:::loggammacenslmrob.MM.control())
     + MMNP <- dget(file='MMnpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(MMNPTest, MMNP, tol = 2e-6)
     + )
     + }
     Error: MMNPTest and MMNP are not equal:
     Component "coefficients": Mean relative difference: 0.007036949
     Component "scale": Mean relative difference: 0.002941794
     Component "fitted.values": Mean relative difference: 0.005523447
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.S.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + set.seed(2345)
     + SNP <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + dput(SNP, file='Snpcensreg-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + IX <- cbind(1,X)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + SNPTest <- robustloggamma:::loggammacenslmrob.S(IX,y,delta,control=robustloggamma:::loggammacenslmrob.S.control())
     + SNP <- dget(file='Snpcensreg-savedvalues.R')
     + stopifnot(
     + all.equal(SNPTest, SNP, tol = 2e-5)
     + )
     + }
     Error: SNPTest and SNP are not equal:
     Component "coefficients": Mean relative difference: 0.05346586
     Component "scale": Mean relative difference: 0.0008444163
     Component "fitted.values": Mean relative difference: 0.07052369
     ....
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.oneTML.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneemp$call <- NULL
     + dput(TMLoneemp, file='oneTMLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + TMLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneTML")
     + TMLoneempTest$call <- NULL
     + TMLoneemp <- dget(file='oneTMLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(TMLoneempTest, TMLoneemp, tol = 2e-6)
     + )
     + }
     Error: TMLoneempTest and TMLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.007907289
     Component "mu": Mean relative difference: 0.01296166
     Component "sigma": Mean relative difference: 0.05503404
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
    Running the tests in ‘tests/loggammacenslmrob.oneWL.R’ failed.
    Complete output:
     > library(robustloggamma)
     >
     > do.test <- TRUE
     > if (!do.test) {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneemp <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneemp$call <- NULL
     + dput(WLoneemp, file='oneWLregemp-savedvalues.R')
     + } else {
     + n <- 200
     + p <- 4
     + set.seed(1234)
     + X <- matrix(rnorm(p*n, sd=2), ncol=p)
     + mu <- 2
     + beta <- rep(2,p)
     + sigma <- 2
     + lambda <- 1
     + linear <- mu + X%*%beta
     + y <- rloggamma(n=n, mu=linear, sigma=sigma, lambda=lambda)
     + cens <- rloggamma(n=n, mu=linear+2.5, sigma=sigma, lambda=lambda)
     + delta <- as.numeric(y <= cens)
     + y[delta==0] <- cens[delta==0]
     + w <- rep(1,n)
     + set.seed(2345)
     + WLoneempTest <- loggammacenslmrob(y~X, delta=delta, method="oneWL")
     + WLoneempTest$call <- NULL
     + WLoneemp <- dget(file='oneWLregemp-savedvalues.R')
     + stopifnot(
     + all.equal(WLoneempTest, WLoneemp, tol = 2e-6)
     + )
     + }
     Error: WLoneempTest and WLoneemp are not equal:
     Component "coefficients": Mean relative difference: 0.008262107
     Component "mu": Mean relative difference: 0.02474369
     Component "sigma": Mean relative difference: 0.00240464
     ....
     In addition: Warning message:
     In survreg.fit(X, Y, weights, offset, init = init, controlvals = control, :
     Ran out of iterations and did not converge
     Execution halted
Flavor: r-patched-solaris-x86