Suppress Error Message in R

Suppress error message in R

There is a big difference between suppressing a message and suppressing the response to an error. If a function cannot complete its task, it will of necessity return an error (although some functions have a command-line argument to take some other action in case of error). What you need, as Zoonekynd suggested, is to use try or trycatch to "encapsulate" the error so that your main program flow can continue even when the function fails.

Can't suppress error message in R Markdown?

Use
{r eval = FALSE} . This will stop the code from running.

Here is the code:

```{r eval = FALSE}
token <- "xxxxxxxxxxxxxxxxxxxxxxxxxxx"  #this is your secret token
url <- "myurl.com" #this is your URL
 

result <- postForm(
  uri=url, #pass in url 
  token=token, #pass in token
  content='record',
  format='csv',
  type='flat'
)

tryCatch suppress error message

Make sure you're neither (1) returning an error, nor (2) printing to stderr in your error handling code. Note one gotcha here is message sends its output to stderr.

A minimal way to fulfills both conditions is tryCatch(expr, error = function(e) {})

Suppressing error messages from external functions

This seems to work:

cc <- capture.output(ff <- FixedPoint(sys1,c(1.90,0.04)),type="message") 

where ff now holds the output you want. (Alternately, you could wrap capture.output(...) in invisible() rather than assigning its return value to a variable.)

The problem seems to be that the error message emanates from an un-silence-d try() clause within the package code.

Suppress error message when using fitdist() from the fitdistrplus package

This comes about because fitdist (or actually, mledist which is called by fitdist) is already doing some error catching. The original error is in optim and has been caught, and then mledist prints to the console the error message. So what you're seeing isn't really an error or even a warning, it's a print statement with the content of a caught error message.

The bit of mledist that does this is:

    if (inherits(opttryerror, "try-error")) {
        warnings("The function optim encountered an error and stopped.")
        if (getOption("show.error.messages")) 
            print(attr(opttryerror, "condition"))
        return(list(estimate = rep(NA, length(vstart)), convergence = 100, 
            loglik = NA, hessian = NA, optim.function = opt.fun, 
            fix.arg = fix.arg, optim.method = meth, fix.arg.fun = fix.arg.fun, 
            counts = c(NA, NA)))
    }

This isn't really good practice, precisely because it causes the problem you now have; it stops other people handling errors systematically.

As you can see from that code, you could switch this off by setting the show.error.messages option to FALSE:

options(show.error.messages = FALSE)

but you want to be careful about that as you won't see any error messages for the rest of the R session. You definitely don't want to do it to someone else's session.

Another alternative is to use sink("extra-error-messages.txt") to send all the printing to the console somewhere (maybe even to your error_log.txt but I'm not sure if that would cause problems with multiple things writing to it).

tryCatch() does not suppress the error messages

Desipte the fact that it says it's an error, the message that's being displayed is done not via the error mechanism, but the output is being printed directly to the console because it's already in it's own error handler. If you want to suppress that message, you'll need to capture the output of the function. Then you can ignore that output.
You can do that with

fit_fn <- function(x){
  capture.output(result <- tryCatch(fitdist(x, "exp"), 
           error = function(e){ NULL }))
  result
}
fit_fn(vec)
# NULL

Can't suppress warnings or messages while using nls2::nls2 in R

I'm going to suggest a combination of capture.output(type="message", ...) and try(). Just the try() (or tryCatch()) doesn't catch all of the messages, since they are emitted from deeper within nls2::nls2 ...

cc <- capture.output(type="message",
         res <- try(nls2::nls2(Concentration ~ A * exp(-alpha * Time_min) +
                      B * exp(-beta * Time_min) +
                      G * exp(-gamma * Time_min), 
                      data = DF, start = StartGuess),
    silent=TRUE)
)

In this case res ends up as an object of type try-error: you can detect this and do what you want by testing if (inherits(res,"try-error")) ...

[1] "Error in result[[which.min(ss)]] : \n  attempt to select less than one element in get1index\n"
attr(,"class")
[1] "try-error"
attr(,"condition")
<simpleError in result[[which.min(ss)]]: attempt to select less than one element in get1index>

supress error message of download.file function

Adding options(warn = -1) to the start of your code chunk will suppress the warnings globally. However it is usally a good idea to turn warnings back on afterwards with your previous warning setting.

```{r,results="hide",message=F,echo=F}

oldw <- getOption("warn")
options(warn = -1)
tryCatch(download.file(paste0("https://www.kjqhfkpuc.es"),
            destfile = paste0("report.pdf"),mode = "wb",quiet = T),error = function(e) e)

options(warn = oldw)

```

See this question

---

Related Topics