Error(s) in re-building vignettes:
  ...
--- re-building 'SQUAREM.Rnw' using Sweave

		Information on package 'SQUAREM'

Description:

Package:            SQUAREM
Version:            2017.10-1
Date:               2017-10-03
Title:              Squared Extrapolation Methods for Accelerating
                    EM-Like Monotone Algorithms
Description:        Algorithms for accelerating the convergence of
                    slow, monotone sequences from smooth, contraction
                    mapping such as the EM algorithm. It can be used to
                    accelerate any smooth, linearly convergent
                    acceleration scheme.  A tutorial style introduction
                    to this package is available in a vignette on the
                    CRAN download page or, when the package is loaded
                    in an R session, with vignette("SQUAREM").
Depends:            R (>= 3.0)
Suggests:           setRNG
LazyLoad:           yes
License:            GPL (>= 2)
Author:             Ravi Varadhan
Maintainer:         Ravi Varadhan <ravi.varadhan@jhu.edu>
URL:                http://www.jhsph.edu/agingandhealth/People/Faculty_personal_pages/Varadhan.html
Repository:         CRAN
NeedsCompilation:   no
Packaged:           2017-10-07 19:14:35 UTC; rvaradh1
Date/Publication:   2017-10-07 23:39:30 UTC
Built:              R 4.0.0; ; 2019-12-22 13:47:18 UTC; unix

Index:

fpiter                  Fixed-Point Iteration Scheme
squarem                 Squared Extrapolation Methods for Accelerating
                        Slowly-Convergent Fixed-Point Iterations

Further information is available in the following vignettes in
directory
'/home/hornik/tmp/R.check/r-devel-clang/Work/build/Packages/SQUAREM/doc':

SQUAREM: SQUAREM Tutorial (source, pdf)

Loading required package: setRNG
 ----------- FAILURE REPORT -------------- 
 --- failure: the condition has length > 1 ---
 --- srcref --- 
: 
 --- package (from environment) --- 
SQUAREM
 --- call from context --- 
cyclem2(par, fixptfn, ..., control = ctrl)
 --- call from argument --- 
if (class(p) == "try-error" | any(is.nan(unlist(p))) | any(!is.numeric(p))) stop("Error in function evaluation")
 --- R stacktrace ---
where 1: cyclem2(par, fixptfn, ..., control = ctrl)
where 2: squarem(p0, fixptfn = power.method, A = bodewig.mat, control = list(K = 3, 
    method = "rre"))
where 3: eval(expr, .GlobalEnv)
where 4: eval(expr, .GlobalEnv)
where 5: withVisible(eval(expr, .GlobalEnv))
where 6: doTryCatch(return(expr), name, parentenv, handler)
where 7: tryCatchOne(expr, names, parentenv, handlers[[1L]])
where 8: tryCatchList(expr, classes, parentenv, handlers)
where 9: tryCatch(expr, error = function(e) {
    call <- conditionCall(e)
    if (!is.null(call)) {
        if (identical(call[[1L]], quote(doTryCatch))) 
            call <- sys.call(-4L)
        dcall <- deparse(call)[1L]
        prefix <- paste("Error in", dcall, ": ")
        LONG <- 75L
        sm <- strsplit(conditionMessage(e), "\n")[[1L]]
        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
        if (is.na(w)) 
            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 
                type = "b")
        if (w > LONG) 
            prefix <- paste0(prefix, "\n  ")
    }
    else prefix <- "Error : "
    msg <- paste0(prefix, conditionMessage(e), "\n")
    .Internal(seterrmessage(msg[1L]))
    if (!silent && isTRUE(getOption("show.error.messages"))) {
        cat(msg, file = outFile)
        .Internal(printDeferredWarnings())
    }
    invisible(structure(msg, class = "try-error", condition = e))
})
where 10: try(withVisible(eval(expr, .GlobalEnv)), silent = TRUE)
where 11: evalFunc(ce, options)
where 12: tryCatchList(expr, classes, parentenv, handlers)
where 13: tryCatch(evalFunc(ce, options), finally = {
    cat("\n")
    sink()
})
where 14: driver$runcode(drobj, chunk, chunkopts)
where 15: utils::Sweave(...)
where 16: engine$weave(file, quiet = quiet, encoding = enc)
where 17: doTryCatch(return(expr), name, parentenv, handler)
where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
where 19: tryCatchList(expr, classes, parentenv, handlers)
where 20: tryCatch({
    engine$weave(file, quiet = quiet, encoding = enc)
    setwd(startdir)
    output <- find_vignette_product(name, by = "weave", engine = engine)
    if (!have.makefile && vignette_is_tex(output)) {
        texi2pdf(file = output, clean = FALSE, quiet = quiet)
        output <- find_vignette_product(name, by = "texi2pdf", 
            engine = engine)
    }
    outputs <- c(outputs, output)
}, error = function(e) {
    thisOK <<- FALSE
    fails <<- c(fails, file)
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 
        file, conditionMessage(e)))
})
where 21: tools:::buildVignettes(dir = "/home/hornik/tmp/R.check/r-devel-clang/Work/PKGS/SQUAREM.Rcheck/vign_test/SQUAREM", 
    ser_elibs = "/tmp/RtmpYoEUZk/file2fb36c73ed2e.rds")

 --- value of length: 2 type: logical ---
[1] FALSE FALSE
 --- function from context --- 
function (par, fixptfn, control = list(), ...) 
{
    control.default <- list(K = 2, method = "rre", square = TRUE, 
        step.min0 = 1, step.max0 = 1, mstep = 4, kr = 1, objfn.inc = 1, 
        tol = 1e-07, maxiter = 1500, trace = FALSE, intermed = FALSE)
    namc <- names(control)
    if (!all(namc %in% names(control.default))) 
        stop("unknown names in control: ", namc[!(namc %in% names(control.default))])
    ctrl <- modifyList(control.default, control)
    method <- ctrl$method
    K <- ctrl$K
    square <- ctrl$square
    tol <- ctrl$tol
    maxiter <- ctrl$maxiter
    kr <- ctrl$kr
    trace <- ctrl$trace
    if (trace) 
        cat("Cyclem-2 \n")
    if (K > length(par)) {
        cat("K is too large.  Decrease it.  \n")
        return()
    }
    iter <- 1
    ptmp <- fixptfn(par, ...)
    res <- sqrt(c(crossprod(ptmp - par)))
    par <- ptmp
    conv <- TRUE
    feval <- 1
    while (feval < maxiter & res > tol) {
        extrap <- TRUE
        p <- matrix(NA, nrow = length(par), ncol = K + 2)
        U <- matrix(NA, nrow = length(par), ncol = K + 1)
        p[, 1] <- par
        for (i in 2:(K + 2)) {
            p[, i] <- try(fixptfn(p[, i - 1], ...), silent = TRUE)
            if (class(p[, i]) == "try-error" | any(is.nan(unlist(p[, 
                i]))) | any(!is.numeric(p[, i]))) 
                stop("Error in function evaluation")
            U[, i - 1] <- p[, i] - p[, i - 1]
        }
        feval <- feval + K + 1
        sqKp1 <- sqrt(c(crossprod(U[, K + 1])))
        if (method == "rre") {
            coef <- try(solve(qr(crossprod(U), LAPACK = TRUE, 
                tol = 1e-14), rep(1, K + 1)), silent = TRUE)
            if (class(coef) == "try-error" | any(is.nan(coef))) {
                extrap <- FALSE
            }
            else {
                if (abs(sum(coef)) < 1e-07) 
                  extrap <- FALSE
                coef <- coef/sum(coef)
            }
        }
        if (method == "mpe") {
            coef <- try(solve(qr(U[, -(K + 1)], LAPACK = TRUE, 
                tol = 1e-14), -U[, K + 1]), silent = TRUE)
            if (class(coef) == "try-error" | any(is.nan(coef))) {
                extrap <- FALSE
            }
            else {
                coef <- c(coef, 1)
                if (abs(sum(coef)) < 1e-07) 
                  extrap <- FALSE
                coef <- coef/sum(coef)
            }
        }
        if (!extrap) {
            par <- p[, ncol(p)]
            res <- sqKp1
            iter <- iter + 1
            if (trace) 
                cat(" residual: ", res, "extrapolation: ", extrap, 
                  "\n")
            next
        }
        if (!square) 
            pnew <- c(p[, -(K + 2)] %*% coef)
        if (square) {
            pnew <- rep(0, length(par))
            if (K > 1) {
                for (i in 1:(K - 1)) {
                  p <- try(cbind(p, fixptfn(p[, i + K + 1], ...)), 
                    silent = TRUE)
                  if (class(p) == "try-error" | any(is.nan(unlist(p))) | 
                    any(!is.numeric(p))) 
                    stop("Error in function evaluation")
                }
                feval <- feval + K - 1
            }
            for (i in 0:K) {
                for (j in 0:K) {
                  pnew <- pnew + coef[i + 1] * coef[j + 1] * 
                    p[, i + j + 1]
                }
            }
            sqKp1 <- sqrt(c(crossprod(p[, 2 * K] - p[, 2 * K - 
                1])))
        }
        ptemp <- try(fixptfn(pnew, ...), silent = TRUE)
        feval <- feval + 1
        if (class(ptemp) == "try-error" | any(is.nan(ptemp))) {
            par <- p[, ncol(p)]
            res <- sqKp1
            extrap <- FALSE
        }
        else {
            res <- sqrt(c(crossprod(ptemp - pnew)))
            parnorm <- as.numeric(sqrt(crossprod(p[, ncol(p)])/length(par)))
            if (res <= (kr * (1 + parnorm) + sqKp1)) {
                par <- ptemp
                extrap <- TRUE
            }
            else {
                par <- p[, ncol(p)]
                res <- sqKp1
                extrap <- FALSE
            }
        }
        iter <- iter + 1
        if (trace) 
            cat(" residual: ", res, "extrapolation: ", extrap, 
                "\n")
    }
    if (feval >= maxiter) 
        conv <- FALSE
    return(list(par = par, value.objfn = NA, iter = iter, fpevals = feval, 
        objfevals = 0, convergence = conv))
}
<bytecode: 0x37a88d0>
<environment: namespace:SQUAREM>
 --- function search by body ---
Function cyclem2 in namespace SQUAREM has this body.
 ----------- END OF FAILURE REPORT -------------- 

Error: processing vignette 'SQUAREM.Rnw' failed with diagnostics:
 chunk 16 (label = sq3.bodewig) 
Error in if (class(p) == "try-error" | any(is.nan(unlist(p))) | any(!is.numeric(p))) stop("Error in function evaluation") : 
  the condition has length > 1

--- failed re-building 'SQUAREM.Rnw'

SUMMARY: processing the following file failed:
  'SQUAREM.Rnw'

Error: Vignette re-building failed.
Execution halted