R Manual

https://stat.ethz.ch/R-manual/R-devel/
Admin
The R Manual is comprehensive documentation for R, a free software environment for statistical...
Tokens:4,608,643
Snippets:59,786
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install package with configure arguments

Source: https://stat.ethz.ch/R-manual/R-devel/RHOME/doc/manual/R-exts.html

Command line example for installing a package while passing custom configuration arguments.

```bash
R CMD INSTALL \
  --configure-args='--with-odbc-include=/opt/local/include \
  --with-odbc-lib=/opt/local/lib --with-odbc-manager=iodbc' \
  RODBC
```

--------------------------------

### Install packages with custom configuration

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/install.packages.html

Example of installing multiple packages while providing specific configuration arguments for one of them.

```R
## Not run: 
## A Linux example for Fedora's layout of udunits2 headers.
install.packages(c("ncdf4", "RNetCDF"),
  configure.args = c(RNetCDF = "--with-netcdf-include=/usr/include/udunits2"))

## End(Not run)
```

--------------------------------

### Implement a basic R front-end in C

Source: https://stat.ethz.ch/R-manual/R-devel/RHOME/doc/manual/R-exts.html

A minimal example demonstrating the setup for a command-line front-end, including console I/O and signal handling callbacks.

```C
#define Win32
#include <windows.h>
#include <stdio.h>
#include <Rversion.h>
#define LibExtern __declspec(dllimport) extern
#include <Rembedded.h>
#include <R_ext/RStartup.h>
/* for askok and askyesnocancel */
#include <graphapp.h>

/* for signal-handling code */
#include <psignal.h>

/* simple input, simple output */

/* This version blocks all events: a real one needs to call ProcessEvents
   frequently. See rterm.c and ../system.c for one approach using
   a separate thread for input.
*/
int myReadConsole(const char *prompt, unsigned char *buf, int len, int addtohistory)
{
    fputs(prompt, stdout);
    fflush(stdout);
    if(fgets((char *)buf, len, stdin)) return 1; else return 0;
}

void myWriteConsole(const char *buf, int len)
{
    printf("%s", buf);
}

void myCallBack(void)
{
    /* called during i/o, eval, graphics in ProcessEvents */
}

void myBusy(int which)
{
    /* set a busy cursor ... if which = 1, unset if which = 0 */
}

static void my_onintr(int sig) { UserBreak = 1; }

int main (int argc, char **argv)
{
    structRstart rp;
    Rstart Rp = &rp;
    char Rversion[25], *RHome, *RUser;
```

--------------------------------

### Analyze Installed Packages

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/installed.packages.html

Examples demonstrating how to filter installed packages by priority and extract specific fields like licenses.

```R
## confine search to .Library for speed
str(ip <- installed.packages(.Library, priority = "high"))
ip[, c(1,3:5)]
plic <- installed.packages(.Library, priority = "high", fields = "License")
## what licenses are there:
table( plic[, "License"] )

## Recommended setup (by many pros):
## Keep packages that come with R (priority="high") and all others separate!
## Consequently, .Library, R's "system" library, shouldn't have any
## non-"high"-priority packages :
pSys <- installed.packages(.Library, priority = NA_character_)
length(pSys) == 0 # TRUE under such a setup
```

--------------------------------

### Example of Getting and Setting Working Directory

Source: https://stat.ethz.ch/R-manual/R-devel/library/base/help/getwd.html

Demonstrates capturing the current working directory and restoring it using setwd.

```R
(WD <- getwd())
if (!is.null(WD)) setwd(WD)
```

--------------------------------

### Initialize Soap Film Smooth Example

Source: https://stat.ethz.ch/R-manual/R-devel/library/mgcv/help/smooth.construct.sf.smooth.spec.html

Basic setup for testing soap film smooths using the mgcv package.

```R
require(mgcv)

##########################
## simple test function...
##########################
```

--------------------------------

### Install Manuals

Source: https://stat.ethz.ch/R-manual/R-devel/RHOME/doc/manual/R-admin.html

Install additional documentation in info or PDF formats.

```bash
make install-info
make install-pdf
```

--------------------------------

### Profiling Memory Allocation

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/Rprofmem.html

Example demonstrating how to start profiling, run a task, and stop the profiler to inspect the output.

```R
## Not run: 
## not supported unless R is compiled to support it.
Rprofmem("Rprofmem.out", threshold = 1000)
example(glm)
Rprofmem(NULL)
noquote(readLines("Rprofmem.out", n = 5))

## End(Not run)
```

--------------------------------

### browseURL Examples

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/browseURL.html

Examples demonstrating how to configure the default browser and open specific URLs or local files.

```R
## Not run: 
## for KDE users who want to open files in a new tab
options(browser = "kfmclient newTab")

browseURL("https://www.r-project.org")

## On Windows-only, something like
browseURL("file://d:/R/R-2.5.1/doc/html/index.html",
          browser = "C:/Program Files/Mozilla Firefox/firefox.exe")

## End(Not run)
```

--------------------------------

### Select Installed Packages

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/select.list.html

An example of using select.list to choose from a sorted list of all available R packages.

```R
## Not run: 
select.list(sort(.packages(all.available = TRUE)))

## End(Not run)
```

--------------------------------

### Namespace Examples

Source: https://stat.ethz.ch/R-manual/R-devel/library/base/help/asNamespace.html

Examples demonstrating how to retrieve a namespace environment and inspect its internal information.

```R
nsName <- "stats"
(ns <- asNamespace(nsName)) # <environment: namespace:stats>

## Inverse function of asNamespace() :
environmentName(asNamespace("stats")) # "stats"
environmentName(asNamespace("base"))  # "base"
getNamespaceInfo(ns, "spec")[["name"]] ## -> "stats"


## Only for the daring ones, getting into the bowels (non-API!):
.nsInfEnv <- function(ns)   asNamespace(ns, base.OK = FALSE)[[".__NAMESPACE__."]]
lsNSInfo  <- function(ns, ...) ls(..., envir = .nsInfEnv(ns))
allinfoNS <- function(ns)      as.list(.nsInfEnv(ns), sorted=TRUE)

utils::str(allinfoNS("stats"))
utils::str(allinfoNS("stats4"))
```

--------------------------------

### example(topic, package = NULL, lib.loc = NULL, character.only = FALSE, give.lines = FALSE, setRNG = FALSE)

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/html/example.html

Runs the examples associated with a specific help topic. It can be used to verify package behavior or explore function usage.

```APIDOC
## example(topic, package = NULL, lib.loc = NULL, character.only = FALSE, give.lines = FALSE, setRNG = FALSE)

### Description
Runs the examples provided in the help topic for the specified function or dataset.

### Parameters
- **topic** (character or name) - Required - The name of the help topic to run examples for.
- **package** (character) - Optional - The name of the package where the topic is located.
- **lib.loc** (character) - Optional - A character vector of directory names of R libraries.
- **character.only** (logical) - Optional - If TRUE, the topic argument is treated as a character string.
- **give.lines** (logical) - Optional - If TRUE, returns the lines of code instead of executing them.
- **setRNG** (logical) - Optional - If TRUE, sets the random number generator state to ensure reproducibility.
```

--------------------------------

### Display R CMD INSTALL help

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/INSTALL.html

Command to view all available options for the installation utility.

```bash
R CMD INSTALL --help
```

--------------------------------

### Examples of help.start

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/help.start.html

Basic invocation of the help system and an example of using the remote argument to point to a local R home directory.

```R
help.start()

## the 'remote' arg can be tested by
help.start(remote = paste0("file://", R.home()))
```

--------------------------------

### Example reference for mono.con

Source: https://stat.ethz.ch/R-manual/R-devel/library/mgcv/help/mono.con.html

Reference to the pcls documentation for practical application examples.

```R
## see ?pcls
```

--------------------------------

### Start or stop the dynamic help system

Source: https://stat.ethz.ch/R-manual/R-devel/library/tools/help/R_DISABLE_HTTPD.html

Controls the internal help server state. Setting start to NA will start the server if it is not currently running.

```R
startDynamicHelp(start = TRUE)
```

--------------------------------

### Install and Check Package via Command Line

Source: https://stat.ethz.ch/R-manual/R-devel/RHOME/doc/manual/R-admin.html

Standard procedure for installing a package to a specific library directory and running checks using the installation log.

```bash
R CMD INSTALL -l libdir pkg > pkg.log 2>&1
R CMD check -l libdir --install=check:pkg.log pkg
```

--------------------------------

### Examples of all function usage

Source: https://stat.ethz.ch/R-manual/R-devel/library/base/help/all.html

Practical examples showing how to use all with logical conditions and empty vectors.

```R
range(x <- sort(round(stats::rnorm(10) - 1.2, 1)))
if(all(x < 0)) cat("all x values are negative\n")

all(logical(0))  # true, as all zero of the elements are true.
```

--------------------------------

### Sequence Generation Examples

Source: https://stat.ethz.ch/R-manual/R-devel/library/base/help/seq.int.html

Practical examples demonstrating different parameters for sequence generation.

```R
seq(0, 1, length.out = 11)
seq(stats::rnorm(20)) # effectively 'along'
seq(1, 9, by = 2)     # matches 'end'
seq(1, 9, by = pi)    # stays below 'end'
seq(1, 6, by = 3)
seq(1.575, 5.125, by = 0.05)
seq(17) # same as 1:17, or even better seq_len(17)
```

--------------------------------

### System release examples

Source: https://stat.ethz.ch/R-manual/R-devel/library/base/help/Sys.info.html

Examples of system release strings across different operating systems.

```R
    "4.17.11-200.fc28.x86_64" # Linux (Fedora)
    "3.16.0-5-amd64"          # Linux (Debian)
    "17.7.0"                  # macOS 10.13.6
    "5.11"                    # Solaris
```

--------------------------------

### example(topic, package = NULL, lib.loc = NULL, character.only = FALSE, give.lines = FALSE, local = FALSE, echo = TRUE, verbose = getOption("verbose"), setRNG = FALSE, ask = getOption("example.ask"), ...)

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/example.html

Runs the examples provided in the help topic for a specified function or dataset.

```APIDOC
## example(topic, ...)

### Description
Runs the examples found in the help page for the specified topic. This is useful for demonstrating how a function or dataset is intended to be used.

### Parameters
- **topic** (character or name) - Required - The name of the help topic to run examples for.
- **package** (character) - Optional - The name of the package where the topic is located.
- **lib.loc** (character) - Optional - A character vector of directory names of R libraries.
- **setRNG** (logical) - Optional - If TRUE, the random number generator state is saved before running the example and restored afterwards.
- **give.lines** (logical) - Optional - If TRUE, returns the lines of code instead of executing them.

### Usage Example
```r
# Run examples for a dataset
example(InsectSprays)

# Run examples from a specific package
example("smooth", package = "stats")

# Run examples with RNG state preservation
r1 <- example(quantile, setRNG = TRUE)
```
```

--------------------------------

### Example of reading a startup file

Source: https://stat.ethz.ch/R-manual/R-devel/library/base/help/readRenviron.html

Demonstrates how to read a user-specific .Renviron file.

```R
## Not run:
## re-read a startup file (or read it in a vanilla session)
readRenviron("~/.Renviron")

## End(Not run)
```

--------------------------------

### Linking Examples for R Front-ends

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/html/LINK.html

Examples demonstrating how to link C, Fortran, and C++ programs against R libraries.

```bash
## Not run: ## examples of front-ends linked against R.
## First a C program
CC=`R CMD config CC`
R CMD LINK $CC -o foo foo.o `R CMD config --ldflags`

## if Fortran code has been compiled into ForFoo.o
FLIBS=`R CMD config FLIBS`
R CMD LINK $CC -o foo foo.o ForFoo.o `R CMD config --ldflags` $FLIBS

## And for a C++ front-end
CXX=`R CMD config CXX`
R CMD COMPILE foo.cc
R CMD LINK $CXX -o foo foo.o `R CMD config --ldflags`

## End(Not run)
```

--------------------------------

### Arrange Windows Usage Examples

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/arrangeWindows.html

Demonstrates basic window tiling and how to customize the target windows using the .arrangeWindowsDefaults list.

```R
## Not run: ## Only available on Windows :
arrangeWindows("v")
# This default is useful only in SDI mode:  it will tile any Firefox window
# along with the R windows
.arrangeWindowsDefaults <- list(c("R", "all"), pattern = c("", "Firefox"))
arrangeWindows("v")

## End(Not run)
```

--------------------------------

### Examples of reading SAS datasets

Source: https://stat.ethz.ch/R-manual/R-devel/library/foreign/help/read.ssd.html

Demonstrates reading files from a directory and a Windows-specific path example. Requires a local SAS installation.

```R
## if there were some files on the web we could get a real
## runnable example
## Not run: 
R> list.files("trialdata")
 [1] "baseline.sas7bdat" "form11.sas7bdat"   "form12.sas7bdat"  
 [4] "form13.sas7bdat"   "form22.sas7bdat"   "form23.sas7bdat"  
 [7] "form3.sas7bdat"    "form4.sas7bdat"    "form48.sas7bdat"  
[10] "form50.sas7bdat"   "form51.sas7bdat"   "form71.sas7bdat"  
[13] "form72.sas7bdat"   "form8.sas7bdat"    "form9.sas7bdat"   
[16] "form90.sas7bdat"   "form91.sas7bdat"  
R> baseline <- read.ssd("trialdata", "baseline")
R> form90 <- read.ssd("trialdata", "form90")

## Or for a Windows example
sashome <- "/Program Files/SAS/SAS 9.1"
read.ssd(file.path(sashome, "core", "sashelp"), "retail",
         sascmd = file.path(sashome, "sas.exe"))

## End(Not run)
```

--------------------------------

### Initialize Preliminaries

Source: https://stat.ethz.ch/R-manual/R-devel/library/Matrix/doc/sparseModels.Rnw

Sets global options and loads required packages for the examples.

```R
options(width=75)
library(grDevices) # for R_DEFAULT_PACKAGES=NULL
library(stats)     # ditto
library(utils)     # ditto
```

--------------------------------

### Override R_JAVA_LD_LIBRARY_PATH

Source: https://stat.ethz.ch/R-manual/R-devel/RHOME/doc/manual/R-admin.html

Setting the environment variable before starting R to support installed Java packages.

```bash
R_JAVA_LD_LIBRARY_PATH=/usr/lib/jvm/java-1.8.0/jre/lib/amd64/server
```

--------------------------------

### startDynamicHelp(start = TRUE)

Source: https://stat.ethz.ch/R-manual/R-devel/library/tools/help/R_DISABLE_HTTPD.html

Starts or shuts down the internal R help server for rendering HTML help pages.

```APIDOC
## startDynamicHelp(start = TRUE)

### Description
Starts the internal help server, so that HTML help pages are rendered when requested.

### Arguments
- **start** (logical) - Optional - Whether to start or shut down the dynamic help system. If NA, the server is started if not already running.

### Details
This function starts the internal HTTP server on the loopback interface (127.0.0.1). It can be disabled by setting the environment variable R_DISABLE_HTTPD to a non-empty value or setting options("help.ports") to 0.

### Value
Returns the chosen port number invisibly (0 if the server has been stopped).
```

--------------------------------

### Complete src/init.c Implementation

Source: https://stat.ethz.ch/R-manual/R-devel/RHOME/doc/manual/R-exts.html

A full example of a registration file including visibility macros and routine definitions.

```c
#include <stdlib.h>
#include <R_ext/Rdynload.h>
#include <R_ext/Visibility.h>  // optional

#include "splines.h"

#define CALLDEF(name, n)  {#name, (DL_FUNC) &name, n}

static const R_CallMethodDef R_CallDef[] = {
    CALLDEF(spline_basis, 4),
    CALLDEF(spline_value, 5),
    {NULL, NULL, 0}
};

void
attribute_visible  // optional
R_init_splines(DllInfo *dll)
{
    R_registerRoutines(dll, NULL, R_CallDef, NULL, NULL);
    R_useDynamicSymbols(dll, FALSE);
    R_forceSymbols(dll, TRUE);
}
```

--------------------------------

### Retrieve R Home Directory

Source: https://stat.ethz.ch/R-manual/R-devel/library/base/help/R.home.html

Basic usage of R.home to get the root installation directory.

```R
R.home(component = "home")
```

--------------------------------

### Run R help topic examples

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/example.html

The usage signature for the example() function, defining parameters for topic selection, execution environment, and tag handling.

```R
example(topic, package = NULL, lib.loc = NULL,
        character.only = FALSE, give.lines = FALSE, local = FALSE,
        type = c("console", "html"), echo = TRUE,
        verbose = getOption("verbose"),
        setRNG = FALSE, ask = getOption("example.ask"),
        prompt.prefix = abbreviate(topic, 6),
        catch.aborts = FALSE,
        run.dontrun = FALSE, run.donttest = interactive())
```

--------------------------------

### Get Windows Handle Example

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/getWindowsHandle.html

Conditional check to print the Windows handle if the operating system is Windows.

```R
if(.Platform$OS.type == "windows")
  print( getWindowsHandle() )
```

--------------------------------

### Configure .Renviron and .Rprofile settings

Source: https://stat.ethz.ch/R-manual/R-devel/library/base/help/Rprofile.site.html

Examples for setting environment variables and R options during startup.

```R
## Not run: 
## Example ~/.Renviron on Unix
R_LIBS=~/R/library
PAGER=/usr/local/bin/less

## Example .Renviron on Windows
R_LIBS=C:/R/library
MY_TCLTK="c:/Program Files/Tcl/bin"
# Variable expansion in double quotes, string literals with backslashes in
# single quotes.
R_LIBS_USER="${APPDATA}"'\R-library'

## Example of setting R_DEFAULT_PACKAGES (from R CMD check)
R_DEFAULT_PACKAGES='utils,grDevices,graphics,stats'
# this loads the packages in the order given, so they appear on
# the search path in reverse order.

## Example of .Rprofile
options(width=65, digits=5)
options(show.signif.stars=FALSE)
setHook(packageEvent("grDevices", "onLoad"),
        function(...) grDevices::ps.options(horizontal=FALSE))
set.seed(1234)
.First <- function() cat("\n   Welcome to R!\n\n")
.Last <- function()  cat("\n   Goodbye!\n\n")

## Example of Rprofile.site
local({
  # add MASS to the default packages, set a CRAN mirror
  old <- getOption("defaultPackages"); r <- getOption("repos")
  r["CRAN"] <- "http://my.local.cran"
  options(defaultPackages = c(old, "MASS"), repos = r)
  ## (for Unix terminal users) set the width from COLUMNS if set
  cols <- Sys.getenv("COLUMNS")
  if(nzchar(cols)) options(width = as.integer(cols))
  # interactive sessions get a fortune cookie (needs fortunes package)
  if (interactive())
    fortunes::fortune()
})

## if .Renviron contains
FOOBAR="coo\bar"doh\ex"abc\"def'"

## then we get
# > cat(Sys.getenv("FOOBAR"), "\n")
# coo\bardoh\exabc"def'

## End(Not run)
```

--------------------------------

### Retrieve R variable value

Source: https://stat.ethz.ch/R-manual/R-devel/RHOME/doc/manual/R-exts.html

Example implementation of retrieving a variable from an environment, equivalent to R's get().

```c
SEXP getvar(SEXP name, SEXP rho)
{
    SEXP ans;

    if (!Rf_isString(name) || Rf_length(name) != 1)
        Rf_error("name is not a single string");
    if (!Rf_isEnvironment(rho))
        Rf_error("rho should be an environment");
    ans = R_getVar(Rf_installChar(STRING_ELT(name, 0)), rho, TRUE);
    if (TYPEOF(ans) != REALSXP || Rf_length(ans) == 0)
        Rf_error("value is not a numeric vector with at least one element");
    Rprintf("first value is %f\n", REAL(ans)[0]);
    return R_NilValue;
}
```

--------------------------------

### Examples of make.packages.html

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/make.packages.html.html

Demonstrates basic usage and an interactive call with specific library locations.

```R
## Not run: 
make.packages.html()
# this can be slow for large numbers of installed packages.

## End(Not run)
if(interactive()) # typically fast and quiet
  make.packages.html(lib.loc = .Library, verbose=FALSE)
```

--------------------------------

### Examples of get and mget usage

Source: https://stat.ethz.ch/R-manual/R-devel/library/base/help/dynGet.html

Demonstrates retrieving objects, handling missing values with mget, and inspecting missing arguments.

```R
get("%o%")

## test mget
e1 <- new.env()
mget(letters, e1, ifnotfound = as.list(LETTERS))

## very low-level: get()ing the "missing argument", e.g., inside browser()
ls.str(E <- environment((\(m) \(){})()))  # m : <missing>
str(E$m) # (empty) symbol
ee <- tryCatch(get("m",E), error = function(e) e)
str(ee)
ee
stopifnot(exprs = {
    inherits(ee, "missingArgError") # and
    inherits(ee, "getMissingError")
    ##
    inherits(tryCatch(get0("m", E), error=identity), "getMissingError")
    is.symbol(E$m) # => valid argument to get(), and *also* gets 'missing arg':
    inherits(tryCatch(get ( E$m ) , error=identity), "getMissingError")
})
```

--------------------------------

### Set R_DEFAULT_PACKAGES

Source: https://stat.ethz.ch/R-manual/R-devel/library/base/help/.Rprofile.html

Example of defining default packages to load at startup.

```text
## Example of setting R_DEFAULT_PACKAGES (from R CMD check)
R_DEFAULT_PACKAGES='utils,grDevices,graphics,stats'
# this loads the packages in the order given, so they appear on
# the search path in reverse order.
```

--------------------------------

### Find Reverse Dependencies Example

Source: https://stat.ethz.ch/R-manual/R-devel/library/tools/help/dependsOnPkgs.html

Example demonstrating how to find reverse dependencies for the lattice package.

```R

## there are few dependencies in a vanilla R installation:
## lattice may not be installed
dependsOnPkgs("lattice")
```

--------------------------------

### $methods()

Source: https://stat.ethz.ch/R-manual/R-devel/library/methods/help/ReferenceClasses.html

Manages reference methods for a class. Can retrieve method names, get a specific method, or install new method definitions.

```APIDOC
## $methods(...)

### Description
Retrieves or defines reference methods for a class. When called with no arguments, it returns the names of existing methods. When called with a character string, it returns the specific method. Named arguments are used to install new method definitions into the class.

### Parameters
- **...** (character/function) - Optional - Method names to retrieve or named arguments defining new methods (set to NULL to remove).
```

--------------------------------

### help.start(update = FALSE, gui = "irrelevant", lib.loc = .libPaths(), browser = getOption("browser"), remote = NULL, verbose = getOption("verbose"))

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/help.start.html

Starts the hypertext (HTML) version of R's online documentation.

```APIDOC
## help.start()

### Description
Starts the hypertext (currently HTML) version of R's online documentation.

### Arguments
- **update** (logical) - Optional - Should this attempt to update the package index to reflect the currently available packages.
- **gui** (character) - Optional - Just for compatibility with S-PLUS.
- **lib.loc** (character vector) - Optional - Listing the package libraries to be included.
- **browser** (character or function) - Optional - The name of the program to be used as hypertext browser, or an R function called with a URL.
- **remote** (character) - Optional - A valid URL for the ‘R_HOME’ directory on a remote location.
- **verbose** (logical) - Optional - Indicates if information about the system interface should be printed to the console.

### Examples
help.start()

## the 'remote' arg can be tested by
help.start(remote = paste0("file://", R.home()))
```

--------------------------------

### Interactive Directory Selection Example

Source: https://stat.ethz.ch/R-manual/R-devel/library/tcltk/help/tk_choose.dir.html

Example demonstrating how to trigger the directory selection dialog in an interactive R session.

```R
if (interactive()) tk_choose.dir(getwd(), "Choose a suitable folder")
```

--------------------------------

### Start HTML help system

Source: https://stat.ethz.ch/R-manual/R-devel/RHOME/doc/manual/R-intro.html

Initializes the HTML help system to browse package documentation.

```R
> help.start()
```

--------------------------------

### Zero-finding implementation in R and C

Source: https://stat.ethz.ch/R-manual/R-devel/RHOME/doc/manual/R-exts.html

Example of finding a zero of a univariate function using R for setup and C for the iterative algorithm.

```r
zero <- function(f, guesses, tol = 1e-7) {
    f.check <- function(x) {
        x <- f(x)
        if(!is.numeric(x)) stop("Need a numeric result")
        as.double(x)
    }
    .Call("zero", body(f.check), as.double(guesses), as.double(tol),
          new.env())
}

cube1 <- function(x) (x^2 + 1) * (x - 1.5)
zero(cube1, c(0, 5))
```

```c
SEXP mkans(double x)
{
    // no need for PROTECT() here, as REAL(.) does not allocate:
    SEXP ans = Rf_allocVector(REALSXP, 1);
    REAL(ans)[0] = x;
    return ans;
}
```

```c
double feval(double x, SEXP f, SEXP rho)
{
    // a version with (too) much PROTECT()ion .. "better safe than sorry"
    SEXP symbol, value;
    PROTECT(symbol = Rf_install("x"));
    PROTECT(value = mkans(x));
    Rf_defineVar(symbol, value, rho);
    UNPROTECT(2);
    return(REAL(Rf_eval(f, rho))[0]);
}
```

```c
SEXP zero(SEXP f, SEXP guesses, SEXP stol, SEXP rho)
{
    double x0 = REAL(guesses)[0], x1 = REAL(guesses)[1],
           tol = REAL(stol)[0];
    double f0, f1, fc, xc;
```

```c
    if(tol <= 0.0) Rf_error("non-positive tol value");
    f0 = feval(x0, f, rho); f1 = feval(x1, f, rho);
    if(f0 == 0.0) return mkans(x0);
    if(f1 == 0.0) return mkans(x1);
    if(f0*f1 > 0.0) error("x[0] and x[1] have the same sign");
```

```c
    for(;;) {
        xc = 0.5*(x0+x1);
        if(fabs(x0-x1) < tol) return  mkans(xc);
        fc = feval(xc, f, rho);
        if(fc == 0) return  mkans(xc);
        if(f0*fc > 0.0) {
            x0 = xc; f0 = fc;
        } else {
            x1 = xc; f1 = fc;
        }
    }
}
```

--------------------------------

### R.home Examples

Source: https://stat.ethz.ch/R-manual/R-devel/library/base/html/Rhome.html

Examples demonstrating how to retrieve the R home directory and list files in the bin directory.

```R
## These result quite platform-dependently :
bind(home = R.home(),
      bin  = R.home("bin")) # often the 'bin' sub directory of 'home'
                            # but not always ...
list.files(R.home("bin"))
```

--------------------------------

### Plotting lines and regression models with abline

Source: https://stat.ethz.ch/R-manual/R-devel/library/graphics/help/abline.html

Examples demonstrating coordinate system setup, grid lines, and adding regression lines to plots.

```R
## Setup up coordinate system (with x == y aspect ratio):
plot(c(-2,3), c(-1,5), type = "n", xlab = "x", ylab = "y", asp = 1)
## the x- and y-axis, and an integer grid
abline(h = 0, v = 0, col = "gray60")
text(1,0, "abline( h = 0 )", col = "gray60", adj = c(0, -.1))
abline(h = -1:5, v = -2:3, col = "lightgray", lty = 3)
abline(a = 1, b = 2, col = 2)
text(1,3, "abline( 1, 2 )", col = 2, adj = c(-.1, -.1))

## Simple Regression Lines:
require(stats)
sale5 <- c(6, 4, 9, 7, 6, 12, 8, 10, 9, 13)
plot(sale5)
abline(lsfit(1:10, sale5))
abline(lsfit(1:10, sale5, intercept = FALSE), col = 4) # less fitting

z <- lm(dist ~ speed, data = cars)
plot(cars)
abline(z) # equivalent to abline(reg = z) or
abline(coef = coef(z))

## trivial intercept model
abline(mC <- lm(dist ~ 1, data = cars)) ## the same as
abline(a = coef(mC), b = 0, col = "blue")
```

--------------------------------

### Install Tcl Extension via Terminal

Source: https://stat.ethz.ch/R-manual/R-devel/RHOME/doc/manual/R-exts.html

Example commands to extract and move a Tcl extension package to a directory within the Tcl search path.

```bash
tar xf bwidget-1.9.14.tar.gz
sudo mv bwidget-1.9.14 /usr/local/lib
```

--------------------------------

### Example Usage of promptPackage

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/promptPackage.html

Demonstrates generating a documentation shell for the 'utils' package, displaying it, and cleaning up the temporary file.

```R
filename <- tempfile()
promptPackage("utils", filename = filename)
file.show(filename)
unlink(filename)
```

--------------------------------

### Examples of compareVersion

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/compareVersion.html

Demonstrates comparing different package version strings.

```R
compareVersion("1.0", "1.0-1")
compareVersion("7.2-0","7.1-12")
```

--------------------------------

### testInstalledPackage(pkg, lib.loc = NULL, outDir = ".", types = c("examples", "tests", "vignettes"), srcdir = NULL, Ropts = "", ...)

Source: https://stat.ethz.ch/R-manual/R-devel/library/tools/help/TEST_MC_CORES.html

Tests an individual installed package by running its examples, tests, or vignettes.

```APIDOC
## testInstalledPackage

### Description
Tests an individual installed package.

### Parameters
- **pkg** (string) - Required - Name of an installed package.
- **lib.loc** (string) - Optional - Library path(s) in which to look for the package.
- **outDir** (string) - Optional - The directory into which to write the output files.
- **types** (vector) - Optional - Type(s) of tests to be done (examples, tests, vignettes).
- **srcdir** (string) - Optional - Directory to look for .save files.
- **Ropts** (string) - Optional - Additional options passed to R CMD BATCH.

### Returns
- **integer** - Invisibly 0L for success, 1L for failure.
```

--------------------------------

### Install source package for all sub-architectures

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/INSTALL.html

Use this command to install a single tarball for all available sub-architectures in an R installation.

```bash
R CMD INSTALL --merge-multiarch mypkg_version.tar.gz
```

--------------------------------

### Usage of help.start

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/help.start.html

The standard function signature for starting the R hypertext documentation server.

```R
help.start(update = FALSE, gui = "irrelevant",
           lib.loc = .libPaths(),
           browser = getOption("browser"), remote = NULL,
           verbose = getOption("verbose"))
```

--------------------------------

### Setup Survival Library

Source: https://stat.ethz.ch/R-manual/R-devel/library/survival/doc/methods.R

Initializes the survival package for analysis.

```R
library(survival)
```

--------------------------------

### Override Installation Path

Source: https://stat.ethz.ch/R-manual/R-devel/doc/RHdoc/manual/R-admin.html

Install R into a specific directory tree using the prefix variable during the make install process.

```bash
make prefix=/path/to/here install
```

--------------------------------

### Install R Framework to Custom Location

Source: https://stat.ethz.ch/R-manual/R-devel/RHOME/doc/manual/R-admin.html

Override the default installation path for the R framework during the make install process.

```bash
make prefix=/where/you/want/R.framework/to/go install
```

--------------------------------

### Check Installed Package

Source: https://stat.ethz.ch/R-manual/R-devel/RHOME/doc/manual/R-exts.html

Runs R CMD check on a previously installed package using the installation log for verification.

```bash
Rdev CMD check -l libdir --install=check:pkg.log pkg
```

--------------------------------

### Running and listing R demos

Source: https://stat.ethz.ch/R-manual/R-devel/library/utils/help/demo.html

Examples showing how to list available demos and execute them with different settings.

```R
demo() # for attached packages

## All available demos:
demo(package = .packages(all.available = TRUE))


## Display a demo, pausing between pages
demo(lm.glm, package = "stats", ask = TRUE)

## Display it without pausing
demo(lm.glm, package = "stats", ask = FALSE)


## Not run: 
 ch <- "scoping"
 demo(ch, character = TRUE)

## End(Not run)

## Find the location of a demo
system.file("demo", "lm.glm.R", package = "stats")
```
Tokens:
Raw