Endmemo R Tutorial

abs() function computes the absolute value of numeric data.

abs(x)

> abs(-1)

[1] 1

> abs(20)

[1] 20

> abs(0)

[1] 0

> x <- c(-2,4,0,45,9,-4)
> abs(x)

[1]  2  4  0 45  9  4

> x <- matrix(c(-3,5,-7,1,-9,4),nrow=3,ncol=2,byrow=TRUE)
> abs(x[1,])

[1] 3 5

> abs(x[,1])

[1] 3 7 9

acos() function returns the radian arccosine of number data.

acos(x)

> acos(1)

[1] 0

> acos(0)

[1] 1.570796

> x <- c(-1,-0.866025,-0.707107,-0.5,0,0.5,0.707107,0.866025,1)
> acos(x)

[1] 3.1415926 2.6179931 2.3561948 2.0943951 1.5707963 1.0471976 0.7853979
[8] 0.5235996 0.0000000

acosh() function computes the hyperbolic arccosine of numberic data.

acosh(x)

> acosh(1)

[1] 0

> acosh(1.5)

[1] 0.9624237

> x <- c(1,1.5)
> acosh(x)

[1] 0.0000000 0.9624237

addNA() function adds an N/A level of a factor if there are duplications.

addNA(x, ifany=FALSE)

> x <- rep(1:10)
> x <- c(x,4,5)
> x

 [1]  1  2  3  4  5  6  7  8  9 10  4  5

> factor(x)

 [1] 1  2  3  4  5  6  7  8  9  10 4  5 
Levels: 1 2 3 4 5 6 7 8 9 10

>addNA(x)

 [1] 1  2  3  4  5  6  7  8  9  10 4  5 
Levels: 1 2 3 4 5 6 7 8 9 10 <NA>

addTaskCallback() function registers a R function to be called when a top-level task is completed.

addTaskCallback(f, data=NULL, name=character())

times <- function(total = 3, str="Task a") {
ctr <- 0

function(expr, value, ok, visible) {
ctr <<- ctr + 1
cat(str, ctr, "\n")
if(ctr == total) {
  cat("handler removing itself\n")
}
return(ctr < total)
}

n <- addTaskCallback(times(4))
removeTaskCallback(n)

agrep() function searches for approximate matches to pattern within each element of the string.

agrep(pattern, x, ignore.case=FALSE, value=FALSE, 
      max.distance=0.1, useBytes=FALSE)

> x <- c("R language","and","SAND")
> agrep("an",x)

[1] 1 2

> agrep("an",x, ignore.case=TRUE)

[1] 1 2 3

> agrep("uag",x, ignore.case=TRUE)

[1] 1

> agrep("uag",x, ignore.case=TRUE, max=1)

[1] 1

> agrep("uag",x, ignore.case=TRUE, max=2)

[1] 1 2 3

all() function checks whether all values of a logical vector are true or not.

all(..., na.rm = FALSE)

> x <- c(TRUE,TRUE)
> all(x)

[1] TRUE

> x <- c(TRUE,TRUE,FALSE)
> all(x)

[1] FALSE

> x <- c(TRUE,TRUE,NA)
> all(x)

[1] NA

> all(x, na.rm=TRUE)

[1] TRUE

any() function checks whether there is at one value is true of a logical vector.

any(..., na.rm = FALSE)

> x <- c(TRUE,TRUE)
> any(x)

[1] TRUE

> x <- c(TRUE,TRUE,FALSE)
> any(x)

[1] TRUE

> x <- c(TRUE,TRUE,NA)
> any(x)

[1] TRUE

> all(x, na.rm=TRUE)

[1] TRUE

aov() function is for analysis of variance (ANOVA).

aov(formula, data=NULL, ...)

>x <- read.csv("anova.csv",header=T,sep="\t")

> a = aov(Expression~Subtype, data=x)
> summary(a)

             Df Sum Sq Mean Sq F value Pr(>F)  
Subtype       2   4.75  2.3769   3.991 0.0196 *
Residuals   278 165.59  0.5956                 
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 

>print(model.tables(a,"means"),digits=2)

Tables of means
Grand mean
           
-0.3053381 

 Subtype 
         A     B     C
     -0.18 -0.39 -0.49
rep 143.00 75.00 63.00

> a = aov(Expression~Subtype*Age, data=x)
> summary(a)

             Df Sum Sq Mean Sq F value Pr(>F)  
Subtype       2   4.75   2.377   3.975 0.0199 *
Age           1   0.09   0.095   0.159 0.6905  
Subtype:Age   2   1.04   0.518   0.866 0.4217  
Residuals   275 164.46   0.598                 
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 

>print(model.tables(a,"means"),digits=2)

Tables of means
Grand mean
           
-0.3053381 

 Gender 
         f      m
     -0.39  -0.22
rep 135.00 146.00

 Subtype 
         A     B     C
     -0.22 -0.36 -0.44
rep 143.00 75.00 63.00

 Gender:Subtype 
      Subtype
Gender A   B   C  
   f     0   0  -1
   rep  40  49  46
   m     0  -1   0
   rep 103  26  17

aperm() function transposes an array by permuting its dimensions and optionally resizing it.

aperm(x, perm, resize=TRUE, keep.class=TRUE)

> x <- array(2:9, c(4,5))
> x

     [,1] [,2] [,3] [,4] [,5]
[1,]    2    6    2    6    2
[2,]    3    7    3    7    3
[3,]    4    8    4    8    4
[4,]    5    9    5    9    5

> aperm(x)

     [,1] [,2] [,3] [,4]
[1,]    2    3    4    5
[2,]    6    7    8    9
[3,]    2    3    4    5
[4,]    6    7    8    9
[5,]    2    3    4    5

append() function adds elements to a vector.

append(x, values, after=length(x))

> x <- rep(1:5)
> x

[1] 1 2 3 4 5

> y <- append(x, 100)
> y

[1]   1   2   3   4   5 100

> y <- append(x, 100, after=2)
> y

[1]   1   2 100   3   4   5

apply() function applies a function to margins of an array or matrix.

apply(x,margin,func, ...)

>BOD    #R built-in dataset, Biochemical Oxygen Demand

  Time demand
1    1    8.3
2    2   10.3
3    3   19.0
4    4   16.0
5    5   15.6
6    7   19.8

> apply(BOD,1,sum)

[1]  9.3 12.3 22.0 20.0 20.6 26.8

> apply(BOD,2,sum)

  Time demand 
    22     89 

> apply(BOD,1:2,function(x) 10 * x)

     Time demand
[1,]   10     83
[2,]   20    103
[3,]   30    190
[4,]   40    160
[5,]   50    156
[6,]   70    198

> x <- array(1:9)
> apply(x,1,function(x) x * 10)

[1] 10 20 30 40 50 60 70 80 90

> x <- array(1:9,c(3,3))
> x

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

> apply(x,1,function(x) x * 10) #or apply(x,2,function(x) x * 10)

[1] 10 20 30 40 50 60 70 80 90

> lapply(BOD,sum)

$Time
[1] 22

$demand
[1] 89

> lapply(BOD,mean)

$Time
[1] 3.666667

$demand
[1] 14.83333

> sapply(BOD,sum)

  Time demand 
    22     89 

> sapply(BOD,sum,simplify=FALSE)

$Time
[1] 22

$demand
[1] 89

args() function displays the argument names and corresponding default values of a function or primitive.

args(name)

> args(append)

function (x, values, after = length(x)) 
NULL

> args(plot)

function (x, y, ...) 
NULL

Array is R data type which has multiple dimensions. array() function creates or tests for arrays. dim() function defines the dimension of an array.

array(data=NA, dim=length(data), dimnames=NULL)

> x <- array(1:9)
> x

[1] 1 2 3 4 5 6 7 8 9

> x <- array(1:9,c(3,3))
> x

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

> x <- 1:64
> dim(x) <- c(2,4,8) #dim() converts the vector into array
> is.array(x)

[1] TRUE

> x

, , 1

     [,1] [,2] [,3] [,4]
[1,]    1    3    5    7
[2,]    2    4    6    8

, , 2

     [,1] [,2] [,3] [,4]
[1,]    9   11   13   15
[2,]   10   12   14   16

, , 3

     [,1] [,2] [,3] [,4]
[1,]   17   19   21   23
[2,]   18   20   22   24

, , 4

     [,1] [,2] [,3] [,4]
[1,]   25   27   29   31
[2,]   26   28   30   32

, , 5

     [,1] [,2] [,3] [,4]
[1,]   33   35   37   39
[2,]   34   36   38   40

, , 6

     [,1] [,2] [,3] [,4]
[1,]   41   43   45   47
[2,]   42   44   46   48

, , 7

     [,1] [,2] [,3] [,4]
[1,]   49   51   53   55
[2,]   50   52   54   56

, , 8

     [,1] [,2] [,3] [,4]
[1,]   57   59   61   63
[2,]   58   60   62   64

> x[1,,]

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
[1,]    1    9   17   25   33   41   49   57
[2,]    3   11   19   27   35   43   51   59
[3,]    5   13   21   29   37   45   53   61
[4,]    7   15   23   31   39   47   55   63

> x[1,2,]

[1]  3 11 19 27 35 43 51 59

> x[1,2,1]

[1] 3

asinh() function computes the hyperbolic arcsine of numberic data.

asinh(x)

> asinh(1)

[1] 0.8813736

> asinh(1.5)

[1] 1.194763

> x <- c(1,1.5)
> asinh(x)

[1] 0.8813736 1.1947632

assign() function assigns a value to a name in an environment.

assign(x, value, pos = -1, envir = as.environment(pos),
       inherits = FALSE, immediate = TRUE)

> assign("z",5)
> z

[1] 5

atan() function returns the radian arctangent of number data.

atan(x)

> atan(1)

[1] 0.7853982

> atan(0)

[1] 0

> atan(0.5)

[1] 0.4636476

> x <- c(1, 0, 0.5)
> atan(x)

[1] 0.7853982 0.0000000 0.4636476

atan2(y, x) function returns the radian arctangent between the x-axis and the vector from the origin to (x, y).

atans(y, x)

> atan2(2,1)

[1] 1.107149

> y <- c(2,3)
> x <- c(5,6)
> atan2(y,x)

[1] 0.3805064 0.4636476

atanh() function computes the hyperbolic arctangent of numberic data.

atanh(x)

> atanh(0)

[1] 0

> atanh(1)

[1] Inf

> atanh(0.99)

[1] 2.646652

> x <- c(0,1,0.99)
> atanh(x)

[1] 0.000000      Inf 2.646652

attach() function makes the data available to the R Search Path.

attach(x)

>x <- read.csv("anova.csv",header=T,sep=",")

>x$Gender

  [1] m m m m m f m m f m m f m m m m f m m m m m m f m m m f m m m m f m m m m
 [38] m m m m m m m m m f m f m m m m m f m m f m m f m m m m f m m m m m m m m
 [75] m m f m m m m m f m m m m m m m m m f m m f m m f m f m m f m m f m m f m
[112] m f m m f m m m f m m m f m f m f f f f f f m f m f f f m f f f f m f m f
[149] m f f m f f f f f m f m f f m f f m f f m f f f m f f f m f f f m f f m f
[186] f f m f f m f m m f m f m f f m f f f f f m f f m f f f m m m f m m m f f
[223] f f f f f m m m f m f f m f f f m f f f m f f f f m f m f f f f m f f f m
[260] f f m f f f f f f m f f m f f f f f f m f f
Levels: f m

>gender

Error: object 'Gender' not found

>attach(x)
>Gender

  [1] m m m m m f m m f m m f m m m m f m m m m m m f m m m f m m m m f m m m m
 [38] m m m m m m m m m f m f m m m m m f m m f m m f m m m m f m m m m m m m m
 [75] m m f m m m m m f m m m m m m m m m f m m f m m f m f m m f m m f m m f m
[112] m f m m f m m m f m m m f m f m f f f f f f m f m f f f m f f f f m f m f
[149] m f f m f f f f f m f m f f m f f m f f m f f f m f f f m f f f m f f m f
[186] f f m f f m f m m f m f m f f m f f f f f m f f m f f f m m m f m m m f f
[223] f f f f f m m m f m f f m f f f m f f f m f f f f m f m f f f f m f f f m
[260] f f m f f f f f f m f f m f f f f f f m f f
Levels: f m

>detach(x)
>Gender

Error: object 'Gender' not found

attachNamespace() function attaches a namespace to the search path.

attachNamespace(ns, pos=2, dataPath=NULL, depends=NULL)

attr() function gets or sets specific attributes of an object.

attr(x, which, exact=FALSE)
attr(x, which) <- value

attributes() function accesses an object's attributes.

attributes(obj)
attributes(obj) <- value
mostattributes(obj) <- value

> x <- 3
> attributes(x)

NULL

> x <- matrix(c(3,5,7,1,9,4),nrow=3,ncol=2,byrow=TRUE)
> attributes(x)

$dim
[1] 3 2

> x <- BOD
> x

  Time demand
1    1    8.3
2    2   10.3
3    3   19.0
4    4   16.0
5    5   15.6
6    7   19.8

> attributes(x)

$names
[1] "Time"   "demand"

$row.names
[1] 1 2 3 4 5 6

$class
[1] "data.frame"

$reference
[1] "A1.4, p. 270"

autoload() function on-demand loads of packages.

autoload(name, package, reset = FALSE, ...)
autoloader(name, package, ...)

> require(stats)
> autoload("interpSpline", "splines")
> search()

[1] ".GlobalEnv"        "package:stats"     "package:graphics" 
[4] "package:grDevices" "package:utils"     "package:datasets" 
[7] "package:methods"   "Autoloads"         "package:base"  

> ls("Autoloads")

[1] "interpSpline"

> .Autoloaded

[1] "splines"

> x <- sort(stats::rnorm(12))
> y <- x^2
> is <- interpSpline(x,y)
> search() #splines loaded

 [1] ".GlobalEnv"        "package:splines"   "package:stats"    
 [4] "package:graphics"  "package:grDevices" "package:utils"    
 [7] "package:datasets"  "package:methods"   "Autoloads"        
[10] "package:base"

> detach("package:splines")
> search()

[1] ".GlobalEnv"        "package:stats"     "package:graphics" 
[4] "package:grDevices" "package:utils"     "package:datasets" 
[7] "package:methods"   "Autoloads"         "package:base" 

> is2 <- interpSpline(x,y+x)
> search() #splines loaded

 [1] ".GlobalEnv"        "package:splines"   "package:stats"    
 [4] "package:graphics"  "package:grDevices" "package:utils"    
 [7] "package:datasets"  "package:methods"   "Autoloads"        
[10] "package:base"  

> detach("package:splines")
> search()   #splines unloaded

[1] ".GlobalEnv"        "package:stats"     "package:graphics" 
[4] "package:grDevices" "package:utils"     "package:datasets" 
[7] "package:methods"   "Autoloads" 

backsolve() function solves a system of linear equations where the coefficient matrix is upper triangular.

x <- backsolve (R, b)
backsolve(r, x, k=ncol(r), upper.tri=TRUE, transpose=FALSE)

> r <- rbind(c(1,2,3),c(0,1,1),c(0,0,2))
> y <- backsolve(r, x <- c(8,4,2))
> y

[1] -1  3  1

> r %*% y

     [,1]
[1,]    8
[2,]    4
[3,]    2

> backsolve(r, x, transpose = TRUE)

[1]   8 -12  -5

barplot(...) funtion plot a bar chart. It's usage is:

barplot(height, width = 1, space = NULL,
        names.arg = NULL, legend.text = NULL, beside = FALSE,
        horiz = FALSE, density = NULL, angle = 45,
        col = NULL, border = par("fg"),
        main = NULL, sub = NULL, xlab = NULL, ylab = NULL,
        xlim = NULL, ylim = NULL, xpd = TRUE, log = "",
        axes = TRUE, axisnames = TRUE,
        cex.axis = par("cex.axis"), cex.names = par("cex.axis"),
        inside = TRUE, plot = TRUE, axis.lty = 0, offset = 0,
        add = FALSE, args.legend = NULL, ...)

>x <- c(3,2,6,8,4)
>barplot(x)

>barplot(x,border="tan2",names.arg=c("Jan","Feb","Mar","Apr","May"),
+ xlab="Month",ylab="Revenue",density=c(0,5,20,50,100))

>A <- matrix(c(3,5,7,1,9,4,6,5,2,12,2,1,7,6,8),nrow=3,ncol=5,byrow=TRUE)
>barplot(A,main="total revenue",names.arg=c("Jan","Feb","Mar","Apr","May"),
+ xlab="month",ylab="revenue",col=c("tan2","blue","darkslategray3"))
>legend(x=0.2,y=24,c("soft","hardware","service"),cex=.8, 
+ col=c("tan2","blue","darkslategray3"),pch=c(22,0,0))

>barplot(A,main="total revenue",beside=TRUE,
+ names.arg=c("Jan","Feb","Mar","Apr","May"),
+ xlab="month",ylab="revenue",col=c("tan2","blue","darkslategray3"))
>legend(x=1,y=11,c("soft","hardware","service"),cex=.8, 
+ col=c("tan2","blue","darkslategray3"),pch=c(22,0,0))

basename() function gets the file name and removes all of the path.

basename(x)

> x <- "/usr/local/r/test.R"
> basename(x)

[1] "test.R"

bessel() function computes the bessel function.

besselI(x, nu, expon.scaled = FALSE)
besselK(x, nu, expon.scaled = FALSE)
besselJ(x, nu)
besselY(x, nu)

beta() function return the beta function and the natural logarithm of the beta function.

B(a,b) = Γ(a)Γ(b)/Γ(a+b)

beta(a, b)
lbeta(a, b)

> beta(4,9)

[1] 0.0005050505

> lbeta(4,9)

[1] -7.590852

> x <- c(3,6, 4)
> y <- c(7,4, 12)
> beta(x,y)

[1] 0.0039682540 0.0019841270 0.0001831502

binom.test() function performs binomial test of null hypothesis about binomial distribution.

binom.test(x,n,p=0.5,alternative=c("two.sided","less","greater"),
    conf.level=0.95)

> binom.test(48,100)

        Exact binomial test

data:  48 and 100
number of successes = 48, number of trials = 100, p-value = 0.7644
alternative hypothesis: true probability of success is not equal to 0.5
95 percent confidence interval:
 0.3790055 0.5822102
sample estimates:
probability of success 
                  0.48 

body() function gets or sets the body of a function.

body(f = sys.function(sys.parent()))
body(f, env = environment(fun)) <- value

> f <- function(x) x^3
> f(3)

[1] 27

> body(f) <- quote(x^2)
> f(3)

[1] 9

bquote() function quotes its argument except that terms wrapped in ., and () are evaluated in the specified environment.

bquote(expr, where = parent.frame())

> x <- 5
> bquote(x == x)

x == x

> bquote(x == .(x))

x == 5

> bquote(x == 5)

x == 5

break() function stops a loop, including for loop, while loop, repeat loop.

> x <- 0
> for (i in 1:10) x <- x + i
> x

[1] 55

> x <- 0
> for (i in 1:10) {if (i == 5) break; x <- x + i}
> x

[1] 10

browser() function interrupt the execution of an expression and allow the inspection of the environment where browser was called from.

browser(text="", condition=NULL, expr=TRUE, skipCalls=0L)

builtins() function returns the names of all the built-in objects.

builtins(internal = FALSE)

> length(builtins(internal=TRUE))

[1] 492

> length(builtins())

[1] 1269

by() applies a function to specified subsets of a data frame.

by(data, INDICES, FUN, ..., simplify = TRUE)

>Orange    #R built-in dataset, Growth of Orange Trees

   Tree  age circumference
1     1  118            30
2     1  484            58
3     1  664            87
4     1 1004           115
5     1 1231           120
6     1 1372           142
7     1 1582           145
8     2  118            33
9     2  484            69
10    2  664           111
11    2 1004           156
12    2 1231           172
13    2 1372           203
14    2 1582           203
15    3  118            30
16    3  484            51
17    3  664            75
18    3 1004           108
19    3 1231           115
20    3 1372           139
21    3 1582           140
22    4  118            32
23    4  484            62
24    4  664           112
25    4 1004           167
26    4 1231           179
27    4 1372           209
28    4 1582           214
29    5  118            30
30    5  484            49
31    5  664            81
32    5 1004           125
33    5 1231           142
34    5 1372           174
35    5 1582           177

> x <- by(Orange[,2],Orange[,1],mean)
> x

Orange[, 1]: 3
[1] 922.1429
------------------------------------------------------------ 
Orange[, 1]: 1
[1] 922.1429
------------------------------------------------------------ 
Orange[, 1]: 5
[1] 922.1429
------------------------------------------------------------ 
Orange[, 1]: 2
[1] 922.1429
------------------------------------------------------------ 
Orange[, 1]: 4
[1] 922.1429

> x[1]

$`3`
[1] 922.1429

> x['3']

$`3`
[1] 922.1429

bzfile() function open a bzip2-ed file.

bzfile(description, open = "", encoding = getOption("encoding"),
       compression = 6)

> writ <- bzfile("tp.bz2", "w")  # bzip2-ed file
> cat("writ into bz2 file", "111111111", "", "2222222222", 
+ file = writ, sep = "\n")
> close(writ)
> print(readLines(writ <- bzfile("tp.bz2")))

adLines(writ <- bzfile("tp.bz2")))
[1] "writ into bz2 file" "111111111"          ""                  
[4] "2222222222" 

> close(writ)
> unlink("tp.bz2")

c() function combines its arguments.

c(..., recursive=FALSE)

> x <- c(1,2,3,4)
> x

[1] 1 2 3 4

call() function creates or tests for objects of mode "call".

call(name, ...)
is.call(x)
as.call(x)

> x <- call("sin",pi)
> x

sin(3.14159265358979)

> eval(x)

[1] 1.224606e-16

capabilities() function reports on the optional features which have been compiled into this build of R.

> version

               _                           
platform       x86_64-w64-mingw32          
arch           x86_64                      
os             mingw32                     
system         x86_64, mingw32             
status                                     
major          3                           
minor          0.1                         
year           2013                        
month          05                          
day            16                          
svn rev        62743                       
language       R                           
version.string R version 3.0.1 (2013-05-16)
nickname       Good Sport  

> capabilities()

    jpeg      png     tiff    tcltk      X11     aqua http/ftp  sockets 
    TRUE     TRUE     TRUE     TRUE    FALSE    FALSE     TRUE     TRUE 
  libxml     fifo   cledit    iconv      NLS  profmem    cairo 
    TRUE    FALSE     TRUE     TRUE     TRUE     TRUE     TRUE 

casefold() function translates characters in character vectors, in particular from upper to lower case or vice versa.

casefold(x, upper=FALSE)

> x <- "Endmemo"
> x

[1] "Endmemo"

> casefold(x)

[1] "endmemo"

> casefold(x, upper=TRUE)

[1] "ENDMEMO"

cat() function prints the objects, concatenates the representations.

cat(... , file = "", sep = " ", fill = FALSE, labels = NULL,
    append = FALSE)

> x <- "r tutorial\n"
> cat(x)

r tutorial

cbind() function combines vector, matrix or data frame by columns.

cbind(x1,x2,...)

>x <- read.csv("data1.csv",header=T,sep=",")
>x2 <- read.csv("data2.csv",header=T,sep=",")

>x3 <- cbind(x,x2)
>x3

  Subtype Gender Expression Age     City
1       A      m      -0.54  32 New York
2       A      f      -0.80  21  Houston
3       B      f      -1.03  34  Seattle
4       C      m      -0.41  67  Houston

ceiling() function returns the smallest integers larger than the parameter.

ceiling(x)

> x <- 2.5
> ceiling(x)

[1] 3

> x <- c(3.5, 2.67, 6.2)
> ceiling(x)

[1] 4 3 7

char.expand() function Seeks a unique match of its first argument among the elements of its second. If successful, it returns this element; otherwise, it performs an action specified by the third argument.

char.expand(input, target, nomatch = stop("no match"))

> x <- c("sand","and","land")
> char.expand("an",x,warning("no expand"))

[1] "and"

> char.expand("a",x,warning("no expand"))

[1] "and"

> char.expand("xx",x,warning("no expand"))

[1] NA
Warning message:
In eval(nomatch) : no expand

character() function creates or test for character objects.

character(length = 0)
as.character(x, ...)
is.character(x)

> x <- character()
> x

character(0)

> x <- character(length=5)
> x

[1] "" "" "" "" ""

> x <- 4 + 5
> x

[1] 9

> is.character(x)

[1] FALSE

> as.character(x)

[1] "9"

> y <- as.character(x)
> is.character(y)

[1] TRUE

charmatch() function finds matches between two arguments.

charmatch(x, table, nomatch = NA_integer_)

> charmatch("an",c("and","sand"))

[1] 1

> charmatch("an",c("end","and","sand"))

[1] 2

> charmatch("an","sand")

[1] NA

charToRaw() function converts character to ASCII or "raw" objects.

charToRaw(x)

> x <- "endmemo r tutorial"
> y <- charToRaw(x)
> y

 [1] 65 6e 64 6d 65 6d 6f 20 72 20 74 75 74 6f 72 69 61 6c

> x <- charToRaw("a")
> x

[1] 61

chartr() function do string substitutions.

chartr(old, new, x)

> x <- "endmemo r tutorial"
> chartr("mdi","gfo",x)

[1] "enfgego r tutoroal"

For Example, there are 205 mutations in gene p53 of 514 tumors, while 96 stage IV tumors have 86 mutations. We expect that 96 stage IV tumors should have 96 x 205 / 514 = 38 mutations, while we observed 86. Is that significantly different from the general mutation pattern?

> sam <- matrix(c(86,96,38,96),nrow=2,ncol=2)
> sam

     [,1] [,2]
[1,]   86   38
[2,]   96   96

> chisq.test(sam)

        Pearson's Chi-squared test with Yates' continuity correction

data:  sam
X-squared = 10.7773, df = 1, p-value = 0.001028

> chisq.test(sam)$p.value

[1] 0.001027552

chol() function compute the Choleski factorization of a real symmetric positive-definite square matrix.

chol(x, ...)

> x <- matrix(c(8,1,1,4),2,2)
> x

     [,1] [,2]
[1,]    8    1
[2,]    1    4

> y <- chol(x)
> y

         [,1]      [,2]
[1,] 2.828427 0.3535534
[2,] 0.000000 1.9685020

> x <- matrix(rep(1:4),2,2)
> x

     [,1] [,2]
[1,]    1    3
[2,]    2    4

> y <- chol(x)

Error in chol.default(x) : 
  the leading minor of order 2 is not positive definite

chol2inv() function inverts a symmetric, positive definite square matrix from its Choleski decomposition.

chol2inv(x, size = NCOL(x), LINPACK = FALSE)

> x <- matrix(c(8,1,2,4),2,2)
> x

     [,1] [,2]
[1,]    8    2
[2,]    1    4

> y <- chol2inv(x)
> y

            [,1]      [,2]
[1,]  0.01953125 -0.015625
[2,] -0.01562500  0.062500

choose() function computes the combination _nC_r.

choose(n,r)

> choose(5,2)

[1] 10

> choose(2,1)

[1] 2

draw.circle(...) function draws a circle on the plot. It's usage is:

draw.circle(x,y,radius,nv=100,border=NULL,col=NA,lty=1,lwd=1)

>install.packages("plotrix")

>plot(BOD)

>require(plotrix)
>draw.circle(4,14,2,border="blue",col="tan2")

R possesses a simple generic function mechanism which can be used for an object-oriented style of programming. Method dispatch takes place based on the class of the first argument to the generic function.

class(x)
class(x) <- value
unclass(x)
inherits(x, what, which = FALSE)
oldClass(x)
oldClass(x) <- value

> x <- c(3,5)
> class(x)

[1] "numeric"

> oldClass(x)

NULL

> inherits(x,c("numeric"))

[1] TRUE
> inherits(x,c("character"))
[1] FALSE

readClipboard() function reads in from the clipboard.

close() function close an open handle.

close(handle, type = "rw", ...)

> handle <- open(handle, open="r")

> close(handle)

Let's first have a look of our data file named clustering.csv:

elements S1  S2  S3  S4  S5  S6  S7  S8
R1  -0.0027 0.1057  0.1976  0.0209  0 0.0089  0.0082  0.0209
R2  0 -0.1204 0.2627  0 0 0.283 0.2076  -0.0158
R3  0 -0.1204 0.2627  0 0 0.283 0.2076  -0.0158
R4  0.0142  0 -0.454  0.0101  -0.0213 -0.0084 -0.0121 0.0083
R5  0 0 -0.2334 0.007 0.4151  0 0.0987  0.021
R6  0.0381  0.0644  0.2302  0 0 -0.0476 0.2432  -0.0069
R7  0.0381  0.0644  0.2302  0 0 -0.0476 0.2432  -0.0069
R8  0.0381  0.0644  0.2302  0 0 -0.0476 0.2432  -0.0069
R9  0.0891  -0.1022 -0.4466 -0.4877 -0.0175 -0.0523 -0.4792 -0.0547
R10 0.0046  -0.1539 -0.4645 0 -0.0282 0 -0.0217 0.017
R11 0.0706  0.028 0.3626  0 0.0196  -0.0094 0.3086  0
R12 0.0311  0.0759  0.2119  0 -0.0022 0 0 0.0117
R13 0.0013  0.0702  -0.3176 0.0152  0.0095  -0.0224 0.2069  0.005
R14 0.0491  0.0525  -0.4329 0.0237  -0.0038 -0.0224 0.2065  0.005
R15 0.0256  0.0579  0.1846  0.0024  0.0029  -0.0165 0.4781  -0.0123
R16 -0.0061 -0.1554 -0.0635 0.0121  -0.0282 0 -0.016  0.017
R17 -0.0061 -0.1554 -0.0635 0.0121  -0.0282 0 -0.016  0.017

>x <- read.csv("clustering.csv", header=T, dec=".",sep=",")
>data.hclust <- hclust(dist(t(x[,2:ncol(x)])),method="complete")
>plot(data.hclust)

>label <- data.hclust$labels
>for (i in 1:length(label)){
>    if (i %% 2 == 1) {label[i]<- paste("control_",label[i],sep="");}
>}
>data.hclust$labels <- label
>plot(data.hclust,pointsize=15,units="px",
+ main="Hierarchical Clustering",xlab="Samples")
>rect.hclust(data.hclust,k=4,border="blue")
>groups<-cutree(data.hclust,k=4)

coef() function extracts model coefficients from objects returned by modeling functions.
It's an alias of coefficients().

>x <- c(2,1,3,2,5,3.3,1);
>y <- c(4,2,6,3,8,6,2.2);

>m < lm(y~x) #Linear Regression Model
>c <- coef(lm(y~x))
>c

(Intercept)           x 
  0.5487805   1.5975610 

>abline(c, col="blue")

>cr = cor(y,x,method="pearson")
>cr = round(cr,digits=3)
>cr

[1] 0.978

col() function gets the column number of a matrix.

col(x, as.factor=FALSE)

> x <- matrix(rep(1:9),3,3)
> x

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

> col(x)

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    1    2    3
[3,]    1    2    3

colMeans() function computes the means of columns of matrix.

colMeans(x, na.rm = FALSE, dims = 1)

> x <- matrix(rep(1:9),3,3)
> x

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

> colMeans(x)

[1] 2 5 8

colnames() function retrieve or set the column names of matrix.

colnames(x, do.NULL = TRUE, prefix = "col")
colnames(x) <- value

> x <- read.csv("matrix.csv",header=T,sep="\t")
> colnames(x)

[1] "A1" "A2" "B1" "B2" "C1" "C2"

> x <- as.matrix(BOD)
> x

     Time demand
[1,]    1    8.3
[2,]    2   10.3
[3,]    3   19.0
[4,]    4   16.0
[5,]    5   15.6
[6,]    7   19.8

> is.matrix(x)

[1] TRUE

> colnames(x)

[1] "Time"   "demand"

> colnames(x) <- c("No.","Value")
> x

     No. Value
[1,]   1   8.3
[2,]   2  10.3
[3,]   3  19.0
[4,]   4  16.0
[5,]   5  15.6
[6,]   7  19.8

R has 657 built-in color names. The function colors() will show all of them. All these color names can be used in plot parameters like col=. The function col2rgb() can convert all these colors into RGB numbers.

colSums() function computes the sums of matrix columns.

colSums (x, na.rm = FALSE, dims = 1)

> x <- matrix(rep(1:9),3,3)
> x

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

> colSums(x)

[1]  6 15 24

commandArgs() function prints the command line arguments.

> commandArgs()

[1] "C:\\Program Files\\R\\R-3.0.1\\bin\\x64\\Rgui.exe"

comment() function sets or queries a comment attribute for an objects.

comment(x)
comment(x) <- value

> x <- 3.1415926
> comment(x) <- "pi"
> x

[1] 3.141593

> comment(x)

[1] "pi"

complex() function do complex number calculations.

complex(length.out = 0, real = numeric(), imaginary = numeric(),
        modulus = 1, argument = 0)
as.complex(x, ...)
is.complex(x)
Re(z)
Im(z)
Mod(z)
Arg(z)
Conj(z)

require(graphics)

0i ^ (-3:3)

matrix(1i^ (-6:5), nrow=4) #- all columns are the same
0 ^ 1i # a complex NaN

## create a complex normal vector
z <- complex(real = stats::rnorm(100), imaginary = stats::rnorm(100))
## or also (less efficiently):
z2 <- 1:2 + 1i*(8:9)

## The Arg(.) is an angle:
zz <- (rep(1:4,len=9) + 1i*(9:1))/10
zz.shift <- complex(modulus = Mod(zz), argument= Arg(zz) + pi)
plot(zz, xlim=c(-1,1), ylim=c(-1,1), col="red", asp = 1,
     main = expression(paste("Rotation by "," ", pi == 180^o)))
abline(h=0,v=0, col="blue", lty=3)
points(zz.shift, col="orange")

memCompress() and memDecompress() functions conducts in-memory compression or decompression for raw vectors.

memCompress(from, type = c("gzip", "bzip2", "xz", "none"))
memDecompress(from,
              type = c("unknown", "gzip", "bzip2", "xz", "none"),
              asChar = FALSE)

> txt <- readLines(file.path(R.home("doc"), "COPYING"))
> sum(nchar(txt))

[1] 17671

> txt.gz <- memCompress(txt,"g")
> length(txt.gz)

[1] 6837

R has a series of functions to handle unusual conditions, including errors and warnings.

tryCatch(expr, ..., finally)
withCallingHandlers(expr, ...)

signalCondition(cond)

simpleCondition(message, call = NULL)
simpleError    (message, call = NULL)
simpleWarning  (message, call = NULL)
simpleMessage  (message, call = NULL)

## S3 method for class 'condition'
as.character(x, ...)
## S3 method for class 'error'
as.character(x, ...)
## S3 method for class 'condition'
print(x, ...)
## S3 method for class 'restart'
print(x, ...)

conditionCall(c)
## S3 method for class 'condition'
conditionCall(c)
conditionMessage(c)
## S3 method for class 'condition'
conditionMessage(c)

withRestarts(expr, ...)

computeRestarts(cond = NULL)
findRestart(name, cond = NULL)
invokeRestart(r, ...)
invokeRestartInteractively(r)

isRestart(x)
restartDescription(r)
restartFormals(r)

.signalSimpleWarning(msg, call)
.handleSimpleError(h, msg, call)

tryCatch(1, finally=print("Hello"))
e <- simpleError("test error")
## Not run:
 stop(e)
 tryCatch(stop(e), finally=print("Hello"))
 tryCatch(stop("fred"), finally=print("Hello"))

## End(Not run)
tryCatch(stop(e), error = function(e) e, finally=print("Hello"))
tryCatch(stop("fred"),  error = function(e) e, finally=print("Hello"))
withCallingHandlers({ warning("A"); 1+2 }, warning = function(w) {})
## Not run:
 { withRestarts(stop("A"), abort = function() {}); 1 }

## End(Not run)
withRestarts(invokeRestart("foo", 1, 2), foo = function(x, y) {x + y})

conflicts() function conflicts reports on objects that exist with the same name in two or more places on the search path, usually because an object in the user's workspace or a package is masking a system object of the same name. This helps discover unintentional masking.

conflicts(where = search(), detail = FALSE)

> conflicts()

[1] "body<-"    "kronecker"

showConnections(all = FALSE)
getConnection(what)
closeAllConnections()
stdin()
stdout()
stderr()
isatty(con)

stdin(), stdout() and stderr() are standard connections corresponding to input, output and error on the console respectively (and not necessarily to file streams). They are text-mode connections of class "terminal" which cannot be opened or closed, and are read-only, write-only and write-only respectively. The stdout() and stderr() connections can be re-directed by sink (and in some circumstances the output from stdout() can be split: see the help page). The encoding for stdin() when redirected can be set by the command-line flag --encoding. showConnections returns a matrix of information. If a connection object has been lost or forgotten, getConnection will take a row number from the table and return a connection object for that connection, which can be used to close the connection, for example. However, if there is no R level object referring to the connection it will be closed automatically at the next garbage collection. closeAllConnections closes (and destroys) all user connections, restoring all sink diversions as it does so. isatty returns true if the connection is one of the class "terminal" connections and it is apparently connected to a terminal, otherwise false. This may not be reliable in embedded applications, including GUI consoles.

R built-in Constants includes:

• LETTERS: 26 letters in uppercase
• letters: 26 letters in lowercase
• month.abb: 12 month names in abbreviation form
• month.name: 12 month names in full name
• pi: π

> LETTERS

 [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N"
 [15] "O" "P" "Q" "R" "S" "T" "U" "V" "W" "X" "Y" "Z"

> letters

 [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n"
 [15] "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"

> month.abb

 [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" 
 [8] "Aug" "Sep" "Oct" "Nov" "Dec"

> month.name

 [1] "January" "February" "March" "April" "May" "June"     
 [7] "July" "August" "September" "October" "November" "December" 

> pi

[1] 3.141593

contributors() function prints out all the contributors of R development.

> contributors()

R is a project which is attempting to provide a modern piece of
statistical software for the GNU suite of software.

The current R is the result of a collaborative effort with
contributions from all over the world.


Authors of R.

R was initially written by Robert Gentleman and Ross Ihaka of the
Statistics Department of the University of Auckland.

Since mid-1997 there has been a core group with write access to the R
source, currently consisting of

Douglas Bates
John Chambers
Peter Dalgaard
Seth Falcon
Robert Gentleman
Kurt Hornik
Stefano Iacus
Ross Ihaka
Friedrich Leisch
Uwe Ligges
Thomas Lumley
Martin Maechler
Duncan Murdoch
Paul Murrell
Martyn Plummer
Brian Ripley
Deepayan Sarkar
Duncan Temple Lang
Luke Tierney
Simon Urbanek

plus Heiner Schwarte up to October 1999 and Guido Masarotto up to June 2003.

Current R-core members can be contacted via email to R-project.org
with name made up by replacing spaces by dots in the name listed above.

R would not be what it is today without the invaluable help of these
people, who contributed by donating code, bug fixes and documentation:

Valerio Aimale, Thomas Baier, Henrik Bengtsson, Roger Bivand, 
Ben Bolker, David Brahm, Goran Brostrom, Patrick Burns, Vince Carey,
Saikat DebRoy, Brian D'Urso, Lyndon Drake, Dirk Eddelbuettel, 
Claus Ekstrom, Sebastian Fischmeister, John Fox, Paul Gilbert, 
Yu Gong, Gabor Grothendieck, Frank E Harrell Jr, Torsten Hothorn,
Robert King, Kjetil Kjernsmo, Roger Koenker, Philippe Lambert, 
Jan de Leeuw, Jim Lindsey, Patrick Lindsey, Catherine Loader, 
Gordon Maclean, John Maindonald, David Meyer, Ei-ji Nakama, 
Jens Oehlschaegel, Steve Oncley, Richard O'Keefe, Hubert Palme, 
Roger D. Peng, Jose' C. Pinheiro, Tony Plate, Anthony Rossini,
Jonathan Rougier, Petr Savicky, Guenther Sawitzki, Marc Schwartz,
Detlef Steuer, Bill Simpson, Gordon Smyth, Adrian Trapletti, 
Terry Therneau, Rolf Turner, Bill Venables, Gregory R. Warnes, 
Andreas Weingessel, Morten Welinder, James Wettenhall, Simon Wood and
Achim Zeileis.

Others have written code that has been adopted by R and is
acknowledged in the code files, including

J. D. Beasley, David J. Best, Richard Brent, Kevin Buhr, Michael
A. Covington, Bill Cleveland, Robert Cleveland,, G. W. Cran,
C. G. Ding, Ulrich Drepper, Paul Eggert, J. O. Evans, David M. Gay,
H. Frick, G. W. Hill, Richard H. Jones, Eric Grosse, Shelby Haberman,
Bruno Haible, John Hartigan, Andrew Harvey, Trevor Hastie, Min Long
Lam, George Marsaglia, K. J. Martin, Gordon Matzigkeit,
C. R. Mckenzie, Jean McRae, Cyrus Mehta, Fionn Murtagh, John C. Nash,
Finbarr O'Sullivan, R. E. Odeh, William Patefield, Nitin Patel, Alan
Richardson, D. E. Roberts, Patrick Royston, Russell Lenth, Ming-Jen
Shyu, Richard C. Singleton, S. G. Springer, Supoj Sutanthavibul, Irma
Terpenning, G. E. Thomas, Rob Tibshirani, Wai Wan Tsang, Berwin
Turlach, Gary V. Vaughan, Michael Wichura, Jingbo Wang, M. A. Wong,
and the Free Software Foundation (for autoconf code and utilities).
See also files under src/extras.

Many more, too numerous to mention here, have contributed by sending bug
reports and suggesting various improvements.

Simon Davies whilst at the University of Auckland wrote the original
version of glm().

Julian Harris and Wing Kwong (Tiki) Wan whilst at the University of
Auckland assisted Ross Ihaka with the original Macintosh port.

R was inspired by the S environment which has been principally
developed by John Chambers, with substantial input from Douglas Bates,
Rick Becker, Bill Cleveland, Trevor Hastie, Daryl Pregibon and
Allan Wilks.

A special debt is owed to John Chambers who has graciously contributed
advice and encouragement in the early days of R and later became a
member of the core team.



The R Foundation may decide to give out @R-project.org
email addresses to contributors to the R Project (even without making them
members of the R Foundation) when in the view of the R Foundation this
would help advance the R project.

The R Core Group, Roger Bivand, John Fox and Bill Venables are the
ordinary members of the R Foundation.  In addition, Dirk Eddelbuettel,
Torsten Hothorn, David Meyer, Simon Wood, and Achim Zeileis are also
e-addressable by .@R-project.org.

cos() function computes the cosine value of numeric value.

cos(x)

> cos(pi)

[1] -1

> cos(-pi)

[1] -1

> cos(pi/3)

[1] 0.5

> cos(0)

[1] 1

> x <- c(pi, pi/4, pi/3)
> cos(x)

[1] -1.0000000  0.7071068  0.5000000

X (deg)	X (Rad)	Y=cosine(X)
180 ̊	π	-1
150 ̊	5π/6	-0.866025
135 ̊	3π/4	-0.707107
120 ̊	2π/3	-0.5
90 ̊	π/2	0
60 ̊	π/3	0.5
45 ̊	π/4	0.707107
30 ̊	π/6	0.866025
0 ̊	0	1

cosh() function computes the hyperbolic cosine of numberic data.

cosh(x)

> cosh(1)

[1] 1.543081

> cosh(0.5)

[1] 1.127626

> x <- c(1,0.5)
> cosh(x)

[1] 1.543081 1.127626

crossprod() function returns matrix cross-product.

crossprod(x, y = NULL)
tcrossprod(x, y = NULL)

> x <- matrix(1:9,3,3)
> x

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

> crossprod(x)

     [,1] [,2] [,3]
[1,]   14   32   50
[2,]   32   77  122
[3,]   50  122  194

> tcrossprod(x)

     [,1] [,2] [,3]
[1,]   66   78   90
[2,]   78   93  108
[3,]   90  108  126

Cstack_info() function Reports information on the C stack size and usage (if available).

> Cstack_info()

      size    current  direction eval_depth 
  67108864       8168          1          2 

cummax() function returns the cumulative maxima.

cummax(x)

> cumsum(2:4)

[1] 2 3 4

> x <- c(3,5,9)
> cummax(x)

[1] 3 5 9

> x <- c(3,5,9,2)
> cummax(x)

[1] 3 5 9 9

cummin() function returns the cumulative minima.

cummin(x)

> cummin(2:4)

[1] 2 2 2

> x <- c(3,5,9)
> cummin(x)

[1] 3 3 3

cumprod() function returns the cumulative multiplication results.

cumsum(x)

> cumsum(2:4)

[1]  2  6 24

> x <- c(3,5,9)
> cumprod(x)

[1]   3  15 135

cumsum() function returns the cumulative sums.

cumsum(x)

> cumsum(2:4)

[1] 2 5 9

> x <- c(3,5,9)
> cumsum(x)

[1]  3  8 17

cut() function divides a numeric vector into different ranges.

cut(x, breaks, labels = NULL,
    include.lowest = FALSE, right = TRUE, dig.lab = 3,
    ordered_result = FALSE, ...)

> x <- stats::rnorm(100)
> x

  [1] -0.154103462  0.271704132 -0.234160855  0.764474679  0.438237645
  [6] -0.763854668  1.303402711  0.051660328  1.064258570  0.079144697
 [11] -0.704381407  2.239763673 -0.749203152  0.601148921 -0.174814689
 [16]  0.100238929  0.670921777 -0.351881772 -1.452691553  0.774250401
 [21]  0.985238459 -0.159947063  0.456925349  0.062732203 -0.139094156
 [26] -0.021987877 -0.369758710 -0.623015605  0.818971164  1.024360342
 [31] -1.180039385 -1.126115746 -1.331609773  0.261068252  0.306040509
 [36]  0.186887898  0.039764640  0.618133561  0.808466877  1.530479825
 [41] -0.326594787 -0.525549355 -0.038649831 -0.320394434 -0.116615568
 [46] -0.928403864  1.284014444  0.559523194  0.511753047 -0.093609863
 [51] -1.199423552 -0.358438485 -1.421215594 -0.199430722 -1.285244671
 [56] -0.344308069  0.202383513 -1.044830704  0.009940864 -1.083693166
 [61]  0.985718206  0.942167477  0.077569581  1.456191918 -1.385394960
 [66] -0.174887806 -0.869293103  1.051227075 -0.726361522  0.082628666
 [71]  1.275779587  0.258221666 -0.629207453 -0.589352154 -0.818233970
 [76]  0.028423636 -0.491220068  0.796916741 -1.407925480  0.765093431
 [81] -0.263630781  0.854937357  0.592710059 -0.095388956 -1.064601796
 [86]  0.691149856  0.822038961  0.666786287 -1.062610036 -2.833961199
 [91]  1.570993774 -0.876630726 -0.343492831 -0.480549452  1.494723381
 [96] -2.025528709  0.949853574 -0.917568904 -1.103676434  0.728284402

> c <- cut(x,breaks=-5:5)
> c

  [1] (-1,0]  (0,1]   (-1,0]  (0,1]   (0,1]   (-1,0]  (1,2]   (0,1]   (1,2]  
 [10] (0,1]   (-1,0]  (2,3]   (-1,0]  (0,1]   (-1,0]  (0,1]   (0,1]   (-1,0] 
 [19] (-2,-1] (0,1]   (0,1]   (-1,0]  (0,1]   (0,1]   (-1,0]  (-1,0]  (-1,0] 
 [28] (-1,0]  (0,1]   (1,2]   (-2,-1] (-2,-1] (-2,-1] (0,1]   (0,1]   (0,1]  
 [37] (0,1]   (0,1]   (0,1]   (1,2]   (-1,0]  (-1,0]  (-1,0]  (-1,0]  (-1,0] 
 [46] (-1,0]  (1,2]   (0,1]   (0,1]   (-1,0]  (-2,-1] (-1,0]  (-2,-1] (-1,0] 
 [55] (-2,-1] (-1,0]  (0,1]   (-2,-1] (0,1]   (-2,-1] (0,1]   (0,1]   (0,1]  
 [64] (1,2]   (-2,-1] (-1,0]  (-1,0]  (1,2]   (-1,0]  (0,1]   (1,2]   (0,1]  
 [73] (-1,0]  (-1,0]  (-1,0]  (0,1]   (-1,0]  (0,1]   (-2,-1] (0,1]   (-1,0] 
 [82] (0,1]   (0,1]   (-1,0]  (-2,-1] (0,1]   (0,1]   (0,1]   (-2,-1] (-3,-2]
 [91] (1,2]   (-1,0]  (-1,0]  (-1,0]  (1,2]   (-3,-2] (0,1]   (-1,0]  (-2,-1]
[100] (0,1]  
10 Levels: (-5,-4] (-4,-3] (-3,-2] (-2,-1] (-1,0] (0,1] (1,2] (2,3] ... (4,5]

> summary(c) #or table(c)

c
(-5,-4] (-4,-3] (-3,-2] (-2,-1]  (-1,0]   (0,1]   (1,2]   (2,3]   (3,4]   (4,5] 
      0       0       2      14      35      38      10       1       0       0 

> x <- stats::rnorm(100) #random numbers, different every time
> c <- cut(x,breaks=10,dig.lab=2)
> summary(c)

    (-2,-1.6]   (-1.6,-1.1]  (-1.1,-0.69] (-0.69,-0.24]  (-0.24,0.21] 
            5             5            13            20            18 
  (0.21,0.65]    (0.65,1.1]     (1.1,1.5]       (1.5,2]       (2,2.4] 
           12            14             6             3             4 

> x <- stats::rnorm(100) #random numbers, different every time
> c <- cut(x,breaks=10,dig.lab=2,labels=1:10)
> summary(c)

 1  2  3  4  5  6  7  8  9 10 
 5  5 13 20 18 12 14  6  3  4

> x <- stats::rnorm(100) #random numbers, different every time
> c <- cut(x,breaks=c(-2,0,1,2))
> table(c)

c
(-2,0]  (0,1]  (1,2] 
    52     32     11 

data.class() function determines the class of an object.

data.class(x)

> x <- c(3,5,9)
> data.class(x)

[1] "numeric"

> data.class(letters)

[1] "character"

R data.frame is a powerful data type, especially when processing table (.csv). It can store the data as row and columns according to the table. The difference between data frame and matrix is that the column data of matrix are the same, while the column data of data frame may be of different modes and attributes.

>x <- BOD
>is.matrix(x)

[1] FALSE

>is.data.frame(x)

[1] TURE

>class(x)

[1] "data.frame"

>x

  Time demand
1    1    8.3
2    2   10.3
3    3   19.0
4    4   16.0
5    5   15.6
6    7   19.8

as.data.frame() can coerce a list into a data frame, providing that the components of the list conforms to the restrictions of a data frame.

>y <- x[2,]
>is.list(y)

[1] TRUE

>is.data.frame(y)

[1] TRUE

>x$Time

[1] 1 2 3 4 5 7

>x$demand

[1]  8.3 10.3 19.0 16.0 15.6 19.8

A convenient way to access the columns of a data frame is using attach(), detach() statement. e.g. after attach(x), the column x$demand can be accessed by simply typing demand.

>attach(x)
>demand

[1]  8.3 10.3 19.0 16.0 15.6 19.8

In other words, attach() statement makes the components of the data frame visible. We can do some operations with the variable demand, and the components demand of the data frame will not be changed.

>demand <- demand + 10
>demand

[1] 18.3 20.3 29.0 26.0 25.6 29.8

>x$demand

[1]  8.3 10.3 19.0 16.0 15.6 19.8

Statement detach() is the reverse statement of attach().

>detach(x)
>demand

Error: object 'demand' not found

data.frame is the default data type when you read in a table. Following is a csv table file dataframe.csv, there are "Expression" value vs Subtype "A", "B" and "C" in column 1 and column 2:

>x <- read.csv("dataframe.csv",header=T,sep="\t")
>is.data.frame(x)

[1] TRUE

R has serveral date and time related functions. date() functions returns a date without time as character string. Sys.Date() and Sys.time() returns the system's date and time as a Date and POSIXlt/POSIXct object respectively.

>date()

[1] "Fri Jan 04 17:38:05 2013"

>Sys.time()

[1] "2013-01-04 17:47:39 EST"

>Sys.Date()

[1] "2013-01-04"

>class(date())

[1] "character"

>class(Sys.Date())

[1] "Date"

>class(Sys.time())

[1] "POSIXct" "POSIXt" 

>x <- "19:18:05"
>y <- strptime(x,"%H:%M:%S")
>y

[1] "2013-01-04 19:18:05"

>class(y)

[1] "POSIXlt" "POSIXt"

>y$sec

[1] 5

debug() function sets the debugging flag on a function.

debug(f, text="", condition=NULL)
debugonce(fun, text="", condition=NULL)
undebug(fun)
isdebugged(fun)

When a function is removed from R it should be replaced by a function which calls .Defunct.

.Defunct(new, package = NULL, msg)

> .Defunct

function (new, package = NULL, msg) 
{
    if (missing(msg)) {
        msg <- gettextf("'%s' is defunct.\n", 
        as.character(sys.call(sys.parent())[[1L]]))
        if (!missing(new)) 
            msg <- c(msg, gettextf("Use '%s' instead.\n", new))
        msg <- c(msg, if (!is.null(package)) gettextf("See help(\"Defunct
        \") and help(\"%s-defunct\").", 
            package) else gettext("See help(\"Defunct\")"))
    }
    else msg <- as.character(msg)
    stop(paste(msg, collapse = ""), call. = FALSE, domain = NA)
}

delayedAssign() function delayedAssign creates a promise to evaluate the given expression if its value is requested. This provides direct access to the lazy evaluation mechanism used by R for the evaluation of (interpreted) functions.

delayedAssign(x, value, eval.env = parent.frame(1),
              assign.env = parent.frame(1))

> str <- "R tutorial"
> delayedAssign("x",str)
> str <- "Perl"
> x

[1] "Perl"

> str <- "R tutorial"
> delayedAssign("x",str)
> x

[1] "R tutorial"

density() function computes kernel density estimates.

density(x, bw = "nrd0", adjust = 1,
        kernel = c("gaussian", "epanechnikov", "rectangular",
                   "triangular", "biweight",
                   "cosine", "optcosine"),
        weights = NULL, window = kernel, width,
        give.Rkern = FALSE,
        n = 512, from, to, cut = 3, na.rm = FALSE, ...)

>x <- stats::rnorm(100)
>x

  [1] -0.154103462  0.271704132 -0.234160855  0.764474679  0.438237645
  [6] -0.763854668  1.303402711  0.051660328  1.064258570  0.079144697
 [11] -0.704381407  2.239763673 -0.749203152  0.601148921 -0.174814689
 [16]  0.100238929  0.670921777 -0.351881772 -1.452691553  0.774250401
 [21]  0.985238459 -0.159947063  0.456925349  0.062732203 -0.139094156
 [26] -0.021987877 -0.369758710 -0.623015605  0.818971164  1.024360342
 [31] -1.180039385 -1.126115746 -1.331609773  0.261068252  0.306040509
 [36]  0.186887898  0.039764640  0.618133561  0.808466877  1.530479825
 [41] -0.326594787 -0.525549355 -0.038649831 -0.320394434 -0.116615568
 [46] -0.928403864  1.284014444  0.559523194  0.511753047 -0.093609863
 [51] -1.199423552 -0.358438485 -1.421215594 -0.199430722 -1.285244671
 [56] -0.344308069  0.202383513 -1.044830704  0.009940864 -1.083693166
 [61]  0.985718206  0.942167477  0.077569581  1.456191918 -1.385394960
 [66] -0.174887806 -0.869293103  1.051227075 -0.726361522  0.082628666
 [71]  1.275779587  0.258221666 -0.629207453 -0.589352154 -0.818233970
 [76]  0.028423636 -0.491220068  0.796916741 -1.407925480  0.765093431
 [81] -0.263630781  0.854937357  0.592710059 -0.095388956 -1.064601796
 [86]  0.691149856  0.822038961  0.666786287 -1.062610036 -2.833961199
 [91]  1.570993774 -0.876630726 -0.343492831 -0.480549452  1.494723381
 [96] -2.025528709  0.949853574 -0.917568904 -1.103676434  0.728284402

>d <- density(x)
>d

Call:
        density.default(x = x)

Data: x (100 obs.);     Bandwidth 'bw' = 0.3184

       x                 y            
 Min.   :-3.7891   Min.   :0.0001413  
 1st Qu.:-2.0431   1st Qu.:0.0117442  
 Median :-0.2971   Median :0.0627054  
 Mean   :-0.2971   Mean   :0.1430424  
 3rd Qu.: 1.4489   3rd Qu.:0.2957362  
 Max.   : 3.1949   Max.   :0.4192181 

>plot(density(x),xlim=c(-4,4),col="blueviolet")

deparse() function turns unevaluated expressions into character strings.

deparse(expr, width.cutoff = 60L,
        backtick = mode(expr) %in%
            c("call", "expression", "(", "function"),
        control = c("keepInteger", "showAttributes", "keepNA"),
        nlines = -1L)

> deparse(args(lm))

[1] "function (formula, data, subset, weights, na.action, method = \"qr\", " 
[2] "    model = TRUE, x = FALSE, y = FALSE, qr = TRUE, singular.ok = TRUE, "
[3] "    contrasts = NULL, offset, ...) "                                    
[4] "NULL"     

> deparse(args(lm), width=20)

[1] "function (formula, data, "        "    subset, weights, "           
[3] "    na.action, method = \"qr\", " "    model = TRUE, x = FALSE, "   
[5] "    y = FALSE, qr = TRUE, "       "    singular.ok = TRUE, "        
[7] "    contrasts = NULL, "           "    offset, ...) "               
[9] "NULL"        

When an object is about removed from R it is first deprecated and should include a call to .Deprecated.

.Deprecated(new, package=NULL, msg)

> .Deprecated

function (new, package = NULL, msg, 
          old = as.character(sys.call(sys.parent()))[1L]) 
{
    msg <- if (missing(msg)) {
        msg <- gettextf("'%s' is deprecated.\n", old)
        if (!missing(new)) 
            msg <- c(msg, gettextf("Use '%s' instead.\n", new))
        c(msg, if (!is.null(package)) gettextf("See help(\"Deprecated\")
    and help(\"%s-deprecated\").", 
            package) else gettext("See help(\"Deprecated\")"))
    }
    else as.character(msg)
    warning(paste(msg, collapse = ""), call. = FALSE, domain = NA)
}

det() function calculates the determinant of a matrix. determinant is a generic function that returns separately the modulus of the determinant, optionally on the logarithm scale, and the sign of the determinant.

det(x, ...)
determinant(x, logarithm = TRUE, ...)

> x <- matrix(c(-2,2,-3,-1,1,3,2,0,-1),3,3)
> x

     [,1] [,2] [,3]
[1,]   -2   -1    2
[2,]    2    1    0
[3,]   -3    3   -1

> det(x)

[1] 18

> x <- t(x)
> x

     [,1] [,2] [,3]
[1,]   -2    2   -3
[2,]   -1    1    3
[3,]    2    0   -1

> det(x)

[1] 18

> determinant(x)

$modulus
[1] 2.890372
attr(,"logarithm")
[1] TRUE

$sign
[1] 1

attr(,"class")
[1] "det"

dput() and dget() function write or read an ASCII text representation of an R object to a file or connection, or uses one to recreate the object.

dput(x, file = "",
     control = c("keepNA", "keepInteger", "showAttributes"))
dget(file)

diag() function extracts or replaces the diagonal of a matrix, or constructs a diagonal matrix.

diag(x = 1, nrow, ncol)
diag(x) <- value

> diag(10,3,4)

     [,1] [,2] [,3] [,4]
[1,]   10    0    0    0
[2,]    0   10    0    0
[3,]    0    0   10    0

> diag(3)

     [,1] [,2] [,3]
[1,]    1    0    0
[2,]    0    1    0
[3,]    0    0    1

diff() function returns suitably lagged and iterated differences.

diff(x, ...)
diff(x, lag = 1, differences = 1, ...)

> diff(1:10)

[1] 1 1 1 1 1 1 1 1 1

> diff(c(2,6,3,49,5))

[1]   4  -3  46 -44

difftime() function calculates time differences between two times.

difftime(time1, time2, tz,
         units = c("auto", "secs", "mins", "hours",
                   "days", "weeks"))

> x <- "2013-06-12 19:18:05"
> y <- "2013-06-13 19:18:05"
> difftime(x,y)

Time difference of -1 days

> x <- "2013-06-12 19:18:05"
> y <- "2013-06-13 12:18:23"
> difftime(x,y)

Time difference of -1 days

> y <- "2013-06-13 12:18:23"
> difftime(x,y)

Time difference of -17.005 hours

> difftime(x,y,tz="EST")

Time difference of -17.005 hours

digamma() function returns the first and second derivatives of the logarithm of the gamma function.

digamma(x) = Γ'(x)/Γ(x)

digamma(x)

> x <- c(2,6,3,49,5)
> digamma(x)

[1] 0.4227843 1.7061177 0.9227843 3.8815815 1.5061177

dim() function gets or sets the dimension of a matrix, array or data frame.

dim(x)

>BOD #R Biochemical Oxygen Demand Dataset

  Time demand
1    1    8.3
2    2   10.3
3    3   19.0
4    4   16.0
5    5   15.6
6    7   19.8

>class(BOD)

[1] "data.frame"

>dim(BOD) #get dimension

[1] 6 2

>x <- rep(1:20)
>x

 [1]  1  2  3  4  5  6  7  8  9 10

>dim(x) <- c(2,5)
>x

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    3    5    7    9
[2,]    2    4    6    8   10

dimnames() function retrieve or set the dimnames of an object.

dimnames(x)
dimnames(x) <- value

> x <- read.csv("matrix.csv",header=T,sep="\t")
> dimnames(x)

[[1]]
[1] "1" "2" "3" "4" "5" "6" "7" "8" "9"

[[2]]
[1] "Subtype"    "Expression" "Quality"    "Height

dir() function lists all the files in a directory.

dir(path = ".", pattern = NULL, all.files = FALSE,
   full.names = FALSE, recursive = FALSE,
   ignore.case = FALSE, include.dirs = FALSE)

dirname() function gets the directory name of a file.

dirname(x)

> x <- "/usr/local/r/test.R"
> dirname(x)

[1] "/usr/local/r"

double() function creates a double-precision vector with default value 0.

double(length = 0)
as.double(x, ...)
is.double(x)

> x <- double(5)
> x

[1] 0 0 0 0 0

dQuote() function double quote text, sQuote() function single quote text.

sQuote(x)
dQuote(x)

> x <- "2013-06-12 19:18:05"
> sQuote(x)

[1] "‘2013-06-12 19:18:05’"

> dQuote(x)

[1] "“2013-06-12 19:18:05”"

drop() function delete the dimensions of an array which have only one level.

drop(x)

droplevels() function drop unused levels from factor.

droplevels(x,...)
droplevels(x, except, ...)

dump() function takes a vector of names of R objects and produces text representations of the objects on a file or connection. A dump file can usually be sourced into another R (or S) session.

dump(list, file = "dumpdata.R", append = FALSE, 
     control = "all", envir = parent.frame(), evaluate = TRUE)

anyDuplicated() function determines which elements are duplicates in a vector or data frame.

duplicated(x, incomparables = FALSE, ...)

> x <- c(1:5, 3:8, 7,8)
> x

 [1] 1 2 3 4 5 3 4 5 6 7 8 7 8

> duplicated(x)

 [1] FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE FALSE FALSE 
[11] FALSE TRUE TRUE

> x2 <- x[!duplicated(x)]
> x2

[1] 1 2 3 4 5 6 7 8

eapplay() function applies function to the named values from an environment and returns the results as a list.

eapply(env, FUN, ..., all.names = FALSE, USE.NAMES = TRUE)

> ev <- new.env(hash = FALSE)
> ev

<environment: 0x0000000010f1d7d0>

> ev$x <- c(4,9)
> eapply(ev,cumsum)

$x
[1]  4 13

eigen() function calculates eigenvalues and eigenvectors of matrices.

eigen(x, symmetric, only.values = FALSE, EISPACK = FALSE)

> x <- matrix(1:9,3,3)
>x

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

> eigen(x)

$values
[1]  1.611684e+01 -1.116844e+00 -5.700691e-16

$vectors
           [,1]       [,2]       [,3]
[1,] -0.4645473 -0.8829060  0.4082483
[2,] -0.5707955 -0.2395204 -0.8164966
[3,] -0.6770438  0.4038651  0.4082483

> x <- diag(6,4,4)
> x

     [,1] [,2] [,3] [,4]
[1,]    6    0    0    0
[2,]    0    6    0    0
[3,]    0    0    6    0
[4,]    0    0    0    6

> eigen(x)

$values
[1] 6 6 6 6

$vectors
     [,1] [,2] [,3] [,4]
[1,]    0    0    0    1
[2,]    0    0    1    0
[3,]    0    1    0    0
[4,]    1    0    0    0

encodeString() function escapes the strings in a character vector in the same way print.default does, and optionally fits the encoded strings within a field width.

encodeString(x, width = 0, quote = "", na.encode = TRUE,
             justify = c("left", "right", "centre", "none"))

> x <- "r tutorial"
> encodeString(x)

[1] "r tutorial"

> x <- "r tutorial\n"
> encodeString(x)

[1] "r tutorial\\n"

Encoding() function reads or sets the declared encodings for a character vector.

Encoding(x)
Encoding(x) <- value
enc2native(x)
enc2utf8(x)

> x <- "r tutorial"
> Encoding(x)

[1] "unknown"

> x <- "fa\xE7ile"
> Encoding(x)

[1] "latin1"

enquote() function is a simple one-line utility which transforms a call of the form Foo(....) into the call quote(Foo(....)). This is typically used to protect a call from early evaluation.

enquote(cl)

> enquote(lm)

quote(function (formula, data, subset, weights, na.action, method = "qr", 
    model = TRUE, x = FALSE, y = FALSE, qr = TRUE, singular.ok = TRUE, 
    contrasts = NULL, offset, ...) 
{
    ret.x <- x
    ret.y <- y
    cl <- match.call()
    mf <- match.call(expand.dots = FALSE)
    m <- match(c("formula", "data", "subset", "weights", "na.action", 
        "offset"), names(mf), 0L)
    mf <- mf[c(1L, m)]
    mf$drop.unused.levels <- TRUE
    mf[[1L]] <- as.name("model.frame")
    mf <- eval(mf, parent.frame())
    if (method == "model.frame") return(mf) else if (method != 
        "qr") warning(gettextf("method = '%s' is not supported. 
    Using 'qr'", method), domain = NA)
    mt <- attr(mf, "terms")
    y <- model.response(mf, "numeric")
    w <- as.vector(model.weights(mf))
    if (!is.null(w) && !is.numeric(w)) stop("'weights' must be 
      a numeric vector")
    offset <- as.vector(model.offset(mf))
    if (!is.null(offset)) {
        if (length(offset) != NROW(y)) stop(gettextf("number of 
    offsets is %d, should equal %d (number of 
    observations)", length(offset), NROW(y)), domain = NA)
    }
    if (is.empty.model(mt)) {
        x <- NULL
        z <- list(coefficients = if (is.matrix(y)) matrix(, 0, 
            3) else numeric(), residuals = y, fitted.values = 0 * 
            y, weights = w, rank = 0L, df.residual = if (!is.null(w)) 
            sum(w != 0) else if (is.matrix(y)) nrow(y) else length(y))
        if (!is.null(offset)) {
            z$fitted.values <- offset
            z$residuals <- y - offset
        }
    } else {
        x <- model.matrix(mt, mf, contrasts)
        z <- if (is.null(w)) lm.fit(x, y, offset = offset, 
       singular.ok = singular.ok, ...) 
       else lm.wfit(x, y, w, offset = offset, 
       singular.ok = singular.ok, ...)
    }
    class(z) <- c(if (is.matrix(y)) "mlm", "lm")
    z$na.action <- attr(mf, "na.action")
    z$offset <- offset
    z$contrasts <- attr(x, "contrasts")
    z$xlevels <- .getXlevels(mt, mf)
    z$call <- cl
    z$terms <- mt
    if (model) z$model <- mf
    if (ret.x) z$x <- x
    if (ret.y) z$y <- y
    if (!qr) z$qr <- NULL
    z
})

environment(fun = NULL)
environment(fun) <- value
is.environment(x)
.GlobalEnv
globalenv()
.BaseNamespaceEnv
emptyenv()
baseenv()
new.env(hash = TRUE, parent = parent.frame(), size = 29L)
parent.env(env)
parent.env(env) <- value
environmentName(env)
env.profile(env)

These functions represent an experimental interface for adjustments to environments and bindings within environments. They allow for locking environments as well as individual bindings, and for linking a variable to a function.

lockEnvironment(env, bindings = FALSE)
environmentIsLocked(env)
lockBinding(sym, env)
unlockBinding(sym, env)
bindingIsLocked(sym, env)
makeActiveBinding(sym, fun, env)
bindingIsActive(sym, env)

eval() function evaluates an R expression in a specified environment.

eval(expr, envir = parent.frame(),
           enclos = if(is.list(envir) || is.pairlist(envir))
                       parent.frame() else baseenv())
evalq(expr, envir, enclos)
eval.parent(expr, n = 1)
local(expr, envir = new.env())

> x <- 5
> eval(x * 3)

[1] 15

> eval(sin(pi/2))

[1] 1

exists() function looks for an R object of the given name.

exists(x, where = -1, envir = , frame, mode = "any", inherits = TRUE)

> exists("lm")

[1] TRUE

> exists("sin")

[1] TRUE

exp(x) function compute the exponential value of a number or number vector, e^x.

> x <- 5
> exp(x)

[1] 148.4132

> y <- rep(1:20)
> exp(y)

         [,1]     [,2]     [,3]     [,4]      [,5]
[1,] 2.718282 20.08554 148.4132 1096.633  8103.084
[2,] 7.389056 54.59815 403.4288 2980.958 22026.466

> 2^3

[1] 8

> 4 ^ (1/2)

[1] 2

> expm1(5)

[1] 147.4132

> expm1(rep(1:20))

         [,1]     [,2]     [,3]     [,4]      [,5]
[1,] 1.718282 19.08554 147.4132 1095.633  8102.084
[2,] 6.389056 53.59815 402.4288 2979.958 22025.466

> plot(exp(c(-1,0,0.2,0.3,1,2,3,4,5)),col="darkgreen")

expand.grid() function creates a data frame from all combinations of the supplied vectors or factors.

expand.grid(..., KEEP.OUT.ATTRS = TRUE, stringsAsFactors = TRUE)

> subtype <- c("green","red","yellow")
> height <- c("3.2","2.5","6.1")
> sex <- c("M","F","F")
> expand.grid(subtype,height,sex)

     Var1 Var2 Var3
1   green  3.2    M
2     red  3.2    M
3  yellow  3.2    M
4   green  2.5    M
5     red  2.5    M
6  yellow  2.5    M
7   green  6.1    M
8     red  6.1    M
9  yellow  6.1    M
10  green  3.2    F
11    red  3.2    F
12 yellow  3.2    F
13  green  2.5    F
14    red  2.5    F
15 yellow  2.5    F
16  green  6.1    F
17    red  6.1    F
18 yellow  6.1    F
19  green  3.2    F
20    red  3.2    F
21 yellow  3.2    F
22  green  2.5    F
23    red  2.5    F
24 yellow  2.5    F
25  green  6.1    F
26    red  6.1    F
27 yellow  6.1    F

> expand.grid(subtype,height)

    Var1 Var2
1  green  3.2
2    red  3.2
3 yellow  3.2
4  green  2.5
5    red  2.5
6 yellow  2.5
7  green  6.1
8    red  6.1
9 yellow  6.1

expm1(x) function calculates exp(x) - 1.

expm1(x)

> expm1(2)

[1] 6.389056

> expm1(1)

[1] 1.718282

> expm1(0)

[1] 0

> expm1(10)

[1] 22025.47

expression() function creates or tests an R expression.

expression(...)
is.expression(x)
as.expression(x, ...)

> x <- expression(sin(pi/2))
> x

expression(sin(pi/2))

> eval(x)

[1] 1

> x <- "sin(pi/2)"
> x

[1] "sin(pi/2)"

> eval(x)

[1] "sin(pi/2)"

R factors variable is a vector of categorical data. factor() function creates a factor variable, and calculates the categorical distribution of a vector data.

factor(x = character(), levels, labels = levels,
       exclude = NA, ordered = is.ordered(x))

> v <- c(1,3,5,8,2,1,3,5,3,5)
> is.factor(v)

[1] FALSE

> factor(v)

 [1] 1 3 5 8 2 1 3 5 3 5
Levels: 1 2 3 5 8

> x <- factor(v)
> x

 [1] 1 3 5 8 2 1 3 5 3 5
Levels: 1 2 3 5 8

> is.factor(x)

[1] TRUE

> x <- factor(v, levels=c(2,1))
> x

 [1] 1    <NA> <NA> <NA> 2    1    <NA> <NA> <NA> <NA>
Levels: 2 1

> levels(x) <- c("two","one")
> x

 [1] one    <NA> <NA> <NA> two    one    <NA> <NA> <NA> <NA>
Levels: two one

factorial() function computes the factorial of a number.

factorial(x)

> factorial(2)  #2 × 1

[1] 2

> factorial(1)   #1 × 1

[1] 1

> factorial(3)  #3 × 2 × 1

[1] 6

> factorial(4)  #4 × 3 × 2 × 1

[1] 24

> factorial(c(4,3,2))

[1] 24  6  2

file() function open a file.

file(description = "", open = "", blocking = TRUE,
     encoding = getOption("encoding"), raw = FALSE)

> writ <- file("wfile.csv","w")
> cat("test ...",file=writ,sep="\n")
> close(writ)

find.package() function finds paths of packages.

find.package(package, lib.loc = NULL, quiet = FALSE,
             verbose = getOption("verbose"))
path.package(package, quiet = FALSE)
library()  #List all installed packages

findInterval(x,vec) function finds the indices of x in vec.

findInterval(x, vec, rightmost.closed = FALSE, all.inside = FALSE)

> v <- c(1:10)
> findInterval(3,v)

[1] 3

> v <- c(3,5,9,2,5,32,11)
> findInterval(9,v)

Error in findInterval(9, v) : 'vec' must be sorted non-decreasingly

> v2 <- sort(v)
> v2

[1]  2  3  5  5  9 11 32

> findInterval(9,v2)

[1] 5

> findInterval(5,v2)

[1] 4

is.finite() and is.infinite() functions return a vector of the same length as x, indicating which elements are finite (not infinite and not missing) or infinite.

Inf and -Inf are positive and negative infinity whereas NaN means ‘Not a Number’. (These apply to numeric values and real and imaginary parts of complex values but not to values of integer vectors.) Inf and NaN are reserved words in the R language.

is.finite(x)
is.infinite(x)
is.nan(x)

> is.finite(3)

[1] TRUE

> x <- 3/0
> x

[1] Inf

> is.finite(x)

[1] FALSE

> is.infinite(x)

[1] TRUE

floor() function returns the largest integer not greater than the giving number.

floor(x)

> floor(2.3)

[1] 2

> floor(2)

[1] 2

> floor(-3.2)

[1] -4

flush() function flushes the output stream of a connection open for write/append.

force(x)

R functions to make calls to compiled code that has been loaded into R, including C, Fortran.

.C(.NAME, ..., NAOK = FALSE, DUP = TRUE, PACKAGE, ENCODING)
.Fortran(.NAME, ..., NAOK = FALSE, DUP = TRUE, PACKAGE, ENCODING)
.External(.NAME, ..., PACKAGE)
.Call(.NAME, ..., PACKAGE)

Unlike other program languages, the for loop of R language can be write as for (i in arr) {expr1; expr2 ...}. It goes through the vector arr every time one element i, and execute a group of commands inside the { ... } in each cycle. The break statement can be used to terminate the loop abruptly. If you don't want to terminate the whole loop, but just ignore current cycle, the next statement can do that.

>samples <- c(rep(1:10))
>samples

 [1]  1  2  3  4  5  6  7  8  9 10

>for (thissample in samples)
+{
+   print(thissample)
+}

[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10

>for (thissample in samples)
+{
+    str <- paste(thissample,"is current sample",sep=" ")
+    print(str)
+}

[1] "1 is current sample"
[1] "2 is current sample"
[1] "3 is current sample"
[1] "4 is current sample"
[1] "5 is current sample"
[1] "6 is current sample"
[1] "7 is current sample"
[1] "8 is current sample"
[1] "9 is current sample"
[1] "10 is current sample"

>for (thissample in samples)
+{
+    if (thissample == 3) break
+    str <- paste(thissample,"is current sample",sep=" ")
+    print(str)
+}

[1] "1 is current sample"
[1] "2 is current sample"

>for (thissample in samples)
+{
+    if (thissample %% 2 == 0) next
+    str <- paste(thissample,"is current sample",sep=" ")
+    print(str)
+}

[1] "1 is current sample"
[1] "3 is current sample"
[1] "5 is current sample"
[1] "7 is current sample"
[1] "9 is current sample"

>end <- length(samples)
>begin <- end - 2
>for (thissample in begin:end)
+{
+    str <- paste(thissample,"is current sample",sep=" ")
+    print(str)
+}

[1] "8 is current sample"
[1] "9 is current sample"
[1] "10 is current sample"

formals() function gets or sets the formal arguments of a function.

formals(fun = sys.function(sys.parent()))
formals(fun, envir = environment(fun)) <- value

> formals(dim)

NULL

> formals(split)

$x


$f


$drop
[1] FALSE

$...

format() function formats an R object for pretty printing.

format(x, trim = FALSE, digits = NULL, nsmall = 0L,
       justify = c("left", "right", "centre", "none"),
       width = NULL, na.encode = TRUE, scientific = NA,
       big.mark = "",   big.interval = 3L,
       small.mark = "", small.interval = 5L,
       decimal.mark = ".", zero.print = NULL,
       drop0trailing = FALSE, ...)

> format(pi,digits=4)

[1] "3.142"

> format(pi,digits=4,nsmall=5)

[1] "3.14159"

forwardsolve() function solves a system of linear equations where the coefficient matrix is lower triangular.

x <- forwardsolve(L, b)
forwardsolve(l, x, k=ncol(l), upper.tri=FALSE, transpose=FALSE)

var.test() function performs F-test between 2 normal populations with hypothesis that variances of the 2 populations are equal.

var.test(x, ...)
var.test(x, y, ratio = 1, alternative = c("two.sided", "less", "greater"),
         conf.level = 0.95, ...)

> x <- rnorm(100, mean=0)
> y <- rnorm(100, mean=1)
> var.text(x,y)

        F test to compare two variances

data:  x and y
F = 0.8795, num df = 99, denom df = 99, p-value = 0.5242
alternative hypothesis: true ratio of variances is not equal to 1
95 percent confidence interval:
 0.5917706 1.3071567
sample estimates:
ratio of variances 
         0.8795095 

gamma() function returns the gamma function Γ_x.

> gamma(2)

[1] 1

> gamma(3)

[1] 2

> gamma(4)

[1] 6

> gamma(5)

[1] 24

> gamma(6)

[1] 120

> gamma(c(4,5,6))

[1]   6  24 120

gc() function starts a garbage collection. gcinfo() sets a flag so that automatic collection is either silent (verbose=FALSE) or prints memory usage statistics (verbose=TRUE).

gc(verbose = getOption("verbose"), reset=FALSE)
gcinfo(verbose)

> gc()  #start garbage collection

         used (Mb) gc trigger (Mb) max used (Mb)
Ncells 204746 11.0     407500 21.8   350000 18.7
Vcells 313545  2.4     786432  6.0   786079  6.0

> gcinfo(TRUE)

[1] FALSE

> gc(TRUE)

Garbage collection 95 = 83+8+4 (level 2) ... 
11.0 Mbytes of cons cells used (50%)
2.4 Mbytes of vectors used (40%)
         used (Mb) gc trigger (Mb) max used (Mb)
Ncells 204761 11.0     407500 21.8   350000 18.7
Vcells 313574  2.4     786432  6.0   786079  6.0

> gc.time()

[1] 0 0 0 0 0

gctorture() function provokes garbage collection on (nearly) every memory allocation. Intended to ferret out memory protection bugs. Also makes R run very slowly.

gctorture(on = TRUE)
gctorture2(step, wait = step, inhibit_release = FALSE)

get() function searches for an R object with a given name and return it.

get(x, pos = -1, envir = as.environment(pos), mode = "any",
    inherits = TRUE)

mget(x, envir, mode = "any",
     ifnotfound = list(function(x)
         stop(paste("value for '", x, "' not found", sep = ""),
              call. = FALSE)),
     inherits = FALSE)

> x <- 5
> get("x")

[1] 5

geterrmessage() function gets the last error message.

getLoadedDLLs() function gets a list of all the DLLs that are currently loaded.

getNativeSymbolInfo() function finds and returns as comprehensive a description of one or more dynamically loaded or ‘exported’ built-in native symbols. For each name, it returns information about the name of the symbol, the library in which it is located and, if available, the number of arguments it expects and by which interface it should be called (i.e .Call, .C, .Fortran, or .External). Additionally, it returns the address of the symbol and this can be passed to other C routines which can invoke. Specifically, this provides a way to explicitly share symbols between different dynamically loaded package libraries. Also, it provides a way to query where symbols were resolved, and aids diagnosing strange behavior associated with dynamic resolution.

getNativeSymbolInfo(name, PACKAGE, unlist = TRUE, 
                    withRegistrationInfo = FALSE)

getOption() function allows the user to set and examine a variety of global options which affect the way in which R computes and displays its results.

getOption(x, default = NULL)

srcfile(filename, encoding = getOption("encoding"), Enc = "unknown")
srcfilecopy(filename, lines)
getSrcLines(srcfile, first, last)
srcref(srcfile, lloc)
# S3 method for class 'srcfile'
print(x, ...)
# S3 method for class 'srcfile'
summary(object, ...)
# S3 method for class 'srcfile'
open(con, line, ...)
# S3 method for class 'srcfile'
close(con, ...)
# S3 method for class 'srcref'
print(x, useSource = TRUE, ...)
# S3 method for class 'srcref'
summary(object, useSource = FALSE, ...)
# S3 method for class 'srcref'
as.character(x, useSource = TRUE, ...)
.isOpen(srcfile)

> src <- srcfile("tp.R")
> getSrcLines(src,1,3)
> lines <- getSrcLines(src,1,3)
> lines

[1] "function sum(a,b)" "{"                 "   x <- a + b"    

gettext(..., domain = NULL)
ngettext(n, msg1, msg2, domain = NULL)
bindtextdomain(domain, dirname = NULL)

getwd() function returns the current R working directory.
setwd() function sets the current R working directory.

getwd()
setwd(dir)

> getwd()

[1] "/user/r"

> setwd("/user/")
> getwd("")

[1] "/user/"

> setwd("../")
> getwd()

[1] "/"

gl() function generates factors by specifying the pattern of their levels.

gl(n, k, length = n*k, labels = 1:n, ordered = FALSE)

> gl(3,2,labels = c("green","red","yellow"))

[1] green  green  red    red    yellow yellow
Levels: green red yellow

glm() function fits linear models to the dataset.

glm(formula, family = gaussian, data, weights, subset,
    na.action, start = NULL, etastart, mustart, offset,
    control = list(...), model = TRUE, method = "glm.fit",
    x = FALSE, y = TRUE, contrasts = NULL, ...)

>Orange #R growth of orange trees dataset

   Tree  age circumference
1     1  118            30
2     1  484            58
3     1  664            87
4     1 1004           115
5     1 1231           120
6     1 1372           142
7     1 1582           145
8     2  118            33
9     2  484            69
10    2  664           111
11    2 1004           156
12    2 1231           172
13    2 1372           203
14    2 1582           203
15    3  118            30
16    3  484            51
17    3  664            75
18    3 1004           108
19    3 1231           115
20    3 1372           139
21    3 1582           140
22    4  118            32
23    4  484            62
24    4  664           112
25    4 1004           167
26    4 1231           179
27    4 1372           209
28    4 1582           214
29    5  118            30
30    5  484            49
31    5  664            81
32    5 1004           125
33    5 1231           142
34    5 1372           174
35    5 1582           177

> attach(Orange) #put age, Tree, circumference into R search path
> g <- glm(circumference ~ age + Tree)
> g

Call:  glm(formula = circumference ~ age + Tree)

Coefficients:
(Intercept)       age    Tree.L    Tree.Q    Tree.C    Tree^4  
    17.3997    0.1068   39.9350    2.5199   -8.2671   -4.6955  

Degrees of Freedom: 34 Total (i.e. Null);  29 Residual
Null Deviance:      112400 
Residual Deviance: 6754         AIC: 297.5 

>summary(g)

Call:
glm(formula = circumference ~ age + Tree)

Deviance Residuals: 
    Min       1Q   Median       3Q      Max  
-30.505   -8.790    3.737    7.650   21.859  

Coefficients:
             Estimate Std. Error t value Pr(>|t|)    
(Intercept) 17.399650   5.543461   3.139  0.00388 ** 
age          0.106770   0.005321  20.066  < 2e-16 ***
Tree.L      39.935049   5.768048   6.923 1.31e-07 ***
Tree.Q       2.519892   5.768048   0.437  0.66544    
Tree.C      -8.267097   5.768048  -1.433  0.16248    
Tree^4      -4.695541   5.768048  -0.814  0.42224    
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 

(Dispersion parameter for gaussian family taken to be 232.8927)

    Null deviance: 112366.3  on 34  degrees of freedom
Residual deviance:   6753.9  on 29  degrees of freedom
AIC: 297.51

Number of Fisher Scoring iterations: 2

• gregexpr returns a list of the same length as text each element of which is of the same form as the return value for regexpr, except that the starting positions of every (disjoint) match are given.

gregexpr(pattern, text, ignore.case = FALSE, perl = FALSE,
        fixed = FALSE, useBytes = FALSE)

> x <- "line 4322: He is now 25 years old, and weights 130lbs"
> y <- gregexpr("\\d+",x)
> y

[[1]]
[1]  6 22 48
attr(,"match.length")
[1] 4 2 3
attr(,"useBytes")
[1] TRUE

> if (y[[1]][1] != -1) print("match")

[1] "match"

>str <- c("Regular", "expression", "examples of R language")
>x <- gregexpr("x*ress",str)
>x

[[1]]
[1] -1
attr(,"match.length")
[1] -1
attr(,"useBytes")
[1] TRUE

[[2]]
[1] 4
attr(,"match.length")
[1] 4
attr(,"useBytes")
[1] TRUE

[[3]]
[1] -1
attr(,"match.length")
[1] -1
attr(,"useBytes")
[1] TRUE

Regular Expression Syntax:

R has various functions for regular expression based match and replaces. The grep, grepl, regexpr and gregexpr functions are used for searching for matches, while sub and gsub for performing replacement.

• grep(value = FALSE) returns an integer vector of the indices of the elements of x that yielded a match (or not, for invert = TRUE).

>str <- c("Regular", "expression", "examples of R language")
>x <- grep("ex",str,value=F)
>x

>x <- "line 4322: He is now 25 years old, and weights 130lbs";
>x <- grep("\\d","",x)
>x

[1] 1

• grep(value = TRUE) returns a character vector containing the selected elements of x (after coercion, preserving names but no other attributes).

>x <- grep("ex",str,value=T)
>x

• grepl returns a logical vector (match or not for each element of x).

>x <- grepl("ex",str)
>x
[1] FALSE  TRUE  TRUE

• sub and gsub return a character vector of the same length and with the same attributes as x (after possible coercion to character). Elements of character vectors x which are not substituted will be returned unchanged (including any declared encoding). If useBytes = FALSE a non-ASCII substituted result will often be in UTF-8 with a marked encoding (e.g. if there is a UTF-8 input, and in a multibyte locale unless fixed = TRUE).

>str <- c("Regular", "expression", "examples of R language")
>x <- sub("x.ress","",str)
>x

>x <- sub("x.+e","",str)
>x

>x <- "line 4322: He is now 25 years old, and weights 130lbs";
>x <- gsub("[[:digit:]]","",x)
>x

[1] "line : He is now  years old, and weights lbs"

>x <- "line 4322: He is now 25 years old, and weights 130lbs";
>x <- gsub("\\d+","",x)
>x

[1] "line : He is now  years old, and weights lbs"

• regexpr returns an integer vector of the same length as text giving the starting position of the first match or -1 if there is none, with attribute "match.length", an integer vector giving the length of the matched text (or -1 for no match). The match positions and lengths are in characters unless useBytes = TRUE is used, when they are in bytes.

>str <- c("Regular", "expression", "examples of R language")
>x <- regexpr("x*ress",str)
>x

• gregexpr returns a list of the same length as text each element of which is of the same form as the return value for regexpr, except that the starting positions of every (disjoint) match are given.

>str <- c("Regular", "expression", "examples of R language")
>x <- gregexpr("x*ress",str)
>x

[[1]]
[1] -1
attr(,"match.length")
[1] -1
attr(,"useBytes")
[1] TRUE

[[2]]
[1] 4
attr(,"match.length")
[1] 4
attr(,"useBytes")
[1] TRUE

[[3]]
[1] -1
attr(,"match.length")
[1] -1
attr(,"useBytes")
[1] TRUE

Function Syntax:

grep(pattern, x, ignore.case = FALSE, perl = FALSE, value = FALSE,
     fixed = FALSE, useBytes = FALSE, invert = FALSE)

grepl(pattern, x, ignore.case = FALSE, perl = FALSE,
      fixed = FALSE, useBytes = FALSE)

sub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE,
    fixed = FALSE, useBytes = FALSE)

gsub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE,
     fixed = FALSE, useBytes = FALSE)

regexpr(pattern, text, ignore.case = FALSE, perl = FALSE,
        fixed = FALSE, useBytes = FALSE)

gregexpr(pattern, text, ignore.case = FALSE, perl = FALSE,
         fixed = FALSE, useBytes = FALSE)

Regular Expression Syntax:

grepl returns TRUE if a string contains the pattern, otherwise FALSE; if the parameter is a string vector, returns a logical vector (match or not for each element of the vector).

grepl(pattern, x, ignore.case = FALSE, perl = FALSE,
      fixed = FALSE, useBytes = FALSE)

> x <- "line 4322: He is now 25 years old, and weights 130lbs"
> y <- grepl("\\d+",x)
> y

[1] TRUE

> x <- "line 4322: He is now 25 years old, and weights 130lbs"
> y <- grepl("[[:digit:]]",x)
> y

[1] TRUE

>str <- c("Regular", "expression", "examples of R language")
>x <- grepl("x*ress",str)
>x

Regular Expression Syntax:

gsub() function replaces all matches of a string, if the parameter is a string vector, returns a string vector of the same length and with the same attributes (after possible coercion to character). Elements of string vectors which are not substituted will be returned unchanged (including any declared encoding).

gsub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE,
    fixed = FALSE, useBytes = FALSE)

> x <- "R Tutorial"
> gsub("ut","ot",x)

[1] "R Totorial"

> gsub("tut","ot",x,ignore.case=T))

[1] "R otorial"

> gsub("tut","ot",x)

[1] "R Tutorial"

> x <- "line 4322: He is now 25 years old, and weights 130lbs"
> y <- gsub("\\d+","---",x)
> y

[1] "line ---: He is now --- years old, and weights ---lbs"

> x <- "line 4322: He is now 25 years old, and weights 130lbs"
> y <- gsub("[[:lower:]]","-",x)
> y

[1] "---- 4322: H- -- --- 25 ----- ---, --- ------- 130---"

> x <- c("R Tutorial","PHP Tutorial", "HTML Tutorial")
> gsub("Tutorial","Examples",x)

[1] "R Examples"    "PHP Examples"  "HTML Examples"

Regular Expression Syntax:

gzcon() function provides a modified connection that wraps an existing connection, and decompresses reads or compresses writes through that connection. Standard gzip headers are assumed.

gzcon(con, level = 6, allowNonCompressed = TRUE)

Heatmap needs "ctc" package from bioconductor, to install "ctc" package:

>source("http://bioconductor.org/biocLite.R")
>biocLite("ctc")

heatmap(x, Rowv=NULL, Colv=if(symm)"Rowv" else NULL,
        distfun = dist, hclustfun = hclust,
        reorderfun = function(d,w) reorder(d,w),
        add.expr, symm = FALSE, revC = identical(Colv, "Rowv"),
        scale=c("row", "column", "none"), na.rm = TRUE,
        margins = c(5, 5), ColSideColors, RowSideColors,
        cexRow = 0.2 + 1/log10(nr), cexCol = 0.2 + 1/log10(nc),
        labRow = NULL, labCol = NULL, main = NULL,
        xlab = NULL, ylab = NULL,
        keep.dendro = FALSE, verbose = getOption("verbose"), ...)

elements S1  S2  S3  S4  S5  S6  S7  S8
R1  -0.0027 0.1057  0.1976  0.0209  0 0.0089  0.0082  0.0209
R2  0 -0.1204 0.2627  0 0 0.283 0.2076  -0.0158
R3  0 -0.1204 0.2627  0 0 0.283 0.2076  -0.0158
R4  0.0142  0 -0.454  0.0101  -0.0213 -0.0084 -0.0121 0.0083
R5  0 0 -0.2334 0.007 0.4151  0 0.0987  0.021
R6  0.0381  0.0644  0.2302  0 0 -0.0476 0.2432  -0.0069
R7  0.0381  0.0644  0.2302  0 0 -0.0476 0.2432  -0.0069
R8  0.0381  0.0644  0.2302  0 0 -0.0476 0.2432  -0.0069
R9  0.0891  -0.1022 -0.4466 -0.4877 -0.0175 -0.0523 -0.4792 -0.0547
R10 0.0046  -0.1539 -0.4645 0 -0.0282 0 -0.0217 0.017
R11 0.0706  0.028 0.3626  0 0.0196  -0.0094 0.3086  0
R12 0.0311  0.0759  0.2119  0 -0.0022 0 0 0.0117
R13 0.0013  0.0702  -0.3176 0.0152  0.0095  -0.0224 0.2069  0.005
R14 0.0491  0.0525  -0.4329 0.0237  -0.0038 -0.0224 0.2065  0.005
R15 0.0256  0.0579  0.1846  0.0024  0.0029  -0.0165 0.4781  -0.0123
R16 -0.0061 -0.1554 -0.0635 0.0121  -0.0282 0 -0.016  0.017
R17 -0.0061 -0.1554 -0.0635 0.0121  -0.0282 0 -0.016  0.017

>x <- read.csv("heatmap.csv", header=T, dec=".",sep=",")
>imageVals <- as.matrix(cn[2:nrow(x),2:ncol(x)]);
>heatmap(imageVals)

>rowNames = x[,1];  
>samplecolors <- c("red","red","red","red","blue","blue","blue","blue");
>heatmap(imageVals,labRow=rowNames,ColSideColors=as.vector(samplecolors))

hexmode() function converts or prints integers in hexadecimal format, with as many digits as are needed to display the largest, using leading zeroes as necessary.

as.hexmode(x)
as.character(x, ...)
format(x, width = NULL, upper.case = FALSE, ...)

> x <- 3
> as.hexmode(x)

[1] "3"

> x <- 145
> as.hexmode(x)

[1] "91"

hist(x, breaks = "Sturges", freq = NULL,  ...)

I() function changes the class of an object to indicate that it should be treated ‘as is’.

• In function data.frame. Protecting an object by enclosing it in I() in a call to data.frame inhibits the conversion of character vectors to factors and the dropping of names, and ensures that matrices are inserted as single columns. I can also be used to protect objects which are to be added to a data frame, or converted to a data frame via as.data.frame. It achieves this by prepending the class "AsIs" to the object's classes. Class "AsIs" has a few of its own methods, including for [, as.data.frame, print and format.

• In function formula. There it is used to inhibit the interpretation of operators such as "+", "-", "*" and "^" as formula operators, so they are used as arithmetical operators. This is interpreted as a symbol by terms.formula.

iconv() function uses system facilities to convert a character vector between encodings: the ‘i’ stands for ‘internationalization’.

iconv(x, from = "", to = "", sub = NA, mark = TRUE)
iconvlist()

icuSetCollate() function Controls the way collation is done by ICU (an optional part of the R build).

identical() function is the safe and reliable way to test whether two objects are exactly equal.

identical(x, y, num.eq = TRUE, single.NA = TRUE,
          attrib.as.set = TRUE)

> identical(1,1)

[1] TRUE

> identical(1,2/2)

[1] TRUE

> identical(1,"1")

[1] FALSE

> identical(1/0,Inf)

[1] TRUE

> identical(1, as.integer(1))

[1] FALSE

> identical(0,-0)

[1] TRUE

> identical(NaN,-NaN)

[1] TRUE

identity() function prints a variable.

identity(x)

> identity(BOD)

  Time demand
1    1    8.3
2    2   10.3
3    3   19.0
4    4   16.0
5    5   15.6
6    7   19.8

> x <- 5
> identity(x)

[1] 5

Syntax: if (condition) {...} else {...}. && and || can be used in the condition. If else statement can be nested.

>samples <- c(rep(1:10))
>samples

 [1]  1  2  3  4  5  6  7  8  9 10

>for (thissample in samples)
+{
+    if (thissample %% 2 != 0) next
+    else print(thissample)
+}

[1] 2
[1] 4
[1] 6
[1] 8
[1] 10

>ret<-ifelse(samples>6,2,1)
>ret

 [1] 1 1 1 1 1 1 2 2 2 2

integer() function creates or tests for objects of type integer.

integer(length = 0)
as.integer(x, ...)
is.integer(x)

> integer(length=3)

[1] 0 0 0

> x <- 3
> is.integer(x)

[1] FALSE

> x <- as.integer(3)
> is.integer(x)

[1] TRUE

interaction() function computes a factor which represents the interaction of the given factors. The result of interaction is always unordered.

interaction(..., drop = FALSE, sep = ".", lex.order = FALSE)

> x <- gl(2,4)
> y <- gl(2,2)
> x

[1] 1 1 1 1 2 2 2 2
Levels: 1 2

> y

[1] 1 1 2 2
Levels: 1 2

> interaction(x,y)

[1] 1.1 1.1 1.2 1.2 2.1 2.1 2.2 2.2
Levels: 1.1 2.1 1.2 2.2

intersect() function performs intersection on two vectors.

union(x, y)
intersect(x, y)
setdiff(x, y)
setequal(x, y)
is.element(el, set)

> x <- c(1:5)
> x

[1] 1 2 3 4 5

> y <- c(3:8)
> y

[1] 3 4 5 6 7 8

> union(x,y)

[1] 1 2 3 4 5 6 7 8

> intersect(x,y)

[1] 3 4 5

> setdiff(x,y)

[1] 1 2

> setdiff(y,x)

[1] 6 7 8

> setequal(x,y)

[1] FALSE

> is.element(x,y)

[1] FALSE FALSE  TRUE  TRUE  TRUE

intToBits() function returns a raw vector of 32 times the length of an integer vector with entries 0 and 1.

intToBits(x)

> intToBits(1)

 [1] 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 00 00 00 00 00 00 00
[26] 00 00 00 00 00 00 00

> intToBits(0)

 [1] 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 00 00 00 00 00 00 00
[26] 00 00 00 00 00 00 00

> intToBits(2)

 [1] 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 00 00 00 00 00 00 00
[26] 00 00 00 00 00 00 00

> intToBits(3)

 [1] 01 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 00 00 00 00 00 00 00
[26] 00 00 00 00 00 00 00

intToUtf8() function converts integer to UTF8.

utf8ToInt(x)
intToUtf8(x, multiple=FALSE)

> intToUtf8(3)

[1] "\003"

> intToUtf8(43)

[1] "+"

> intToUtf8(430)

[1] "Ʈ"

isSymmetric() function tests whether matrix is symmetric or not.

isSymmetric(object, ...)
isSymmetric(object, tol = 100 * .Machine$double.eps, ...)

> x <- matrix(1:9,3,3)
> x

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

> isSymmetric(x)

[1] FALSE

> x <- diag(3)
> isSymmetric(x)

[1] TRUE

> x

     [,1] [,2] [,3]
[1,]    1    0    0
[2,]    0    1    0
[3,]    0    0    1

isTRUE() function tests whether value or express is TRUE or not.

! x
x & y
x && y
x | y
x || y
xor(x, y)
isTRUE(x)

> isTRUE(1)

[1] FALSE

> isTRUE(0)

[1] FALSE

> isTRUE(1>0)

[1] TRUE

> isTRUE(TRUE)

[1] TRUE

jitter() function adds a small amount of noise to a numeric vector.

jitter(x, factor=1, amount = NULL)

> jitter(3)

[1] 3.018772

> jitter(3)

[1] 2.987

> jitter(3)

[1] 3.003597

> jitter(3,factor=1000)

[1] -18.7201

> jitter(3,factor=1000)

[1] -47.10491

> jitter(3,factor=1000)

[1] 61.86195

> jitter(3,factor=10,amount=1)

[1] 3.642866

> jitter(rep(4,5))

[1] 4.075898 4.003890 3.934521 3.979925 3.940923

> jitter(rep(2,5))

[1] 2.010194 2.019983 1.997563 2.030967 1.999279

> jitter(rep(0,5))

[1] -0.010258611 -0.003132073  0.017139330 -0.001881735 -0.009311234

kappa() function computes by default (an estimate of) the 2-norm condition number of a matrix or of the R matrix of a QR decomposition, perhaps of a linear fit. The 2-norm condition number can be shown to be the ratio of the largest to the smallest non-zero singular value of the matrix.

The condition number of a regular (square) matrix is the product of the norm of the matrix and the norm of its inverse (or pseudo-inverse), and hence depends on the kind of matrix-norm.
rcond() computes an approximation of the reciprocal condition number.

kappa(z, ...)
kappa(z, exact = FALSE,
      norm = NULL, method = c("qr", "direct"), ...)
kappa(z, ...)
kappa(z, ...)
kappa.tri(z, exact = FALSE, LINPACK = TRUE, norm=NULL, ...)
rcond(x, norm = c("O","I","1"), triangular = FALSE, ...)

> x <- matrix(1:9,3,3)
> kappa(x)

[1] 3.893583e+16

> x

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

> x <- cbind(2,3:9)
> x

     [,1] [,2]
[1,]    2    3
[2,]    2    4
[3,]    2    5
[4,]    2    6
[5,]    2    7
[6,]    2    8
[7,]    2    9

> kappa(x)

[1] 13.6

kronecker() function computes the generalised kronecker product of two arrays, X and Y. kronecker(X, Y) returns an array A with dimensions dim(X) * dim(Y).

kronecker(X, Y, FUN = "*", make.dimnames = FALSE, ...)
X %x% Y

> x <- matrix(1:9,3,3)
> x

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

> kronecker(2,x)

     [,1] [,2] [,3]
[1,]    2    8   14
[2,]    4   10   16
[3,]    6   12   18

> kronecker(5,x)

     [,1] [,2] [,3]
[1,]    5   20   35
[2,]   10   25   40
[3,]   15   30   45

> kronecker(diag(3,2),x)

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    3   12   21    0    0    0
[2,]    6   15   24    0    0    0
[3,]    9   18   27    0    0    0
[4,]    0    0    0    3   12   21
[5,]    0    0    0    6   15   24
[6,]    0    0    0    9   18   27

l10n_info() function reports on localization information.

l10n_info()

>l10n_info()

$MBCS
[1] FALSE

$`UTF-8`
[1] FALSE

$`Latin-1`
[1] TRUE

$codepage
[1] 1252

labels() function finds a suitable set of labels from an object for use in printing or plotting.

labels(object, ...)

> x <- 3
> labels(x)

[1] "1"

> x <- c(3,4,5,9)
> labels(x)

[1] "1" "2" "3" "4"

lapply() function applies a function to a data frame.

lapply(x,func, ...)

>BOD    #R built-in dataset, Biochemical Oxygen Demand

  Time demand
1    1    8.3
2    2   10.3
3    3   19.0
4    4   16.0
5    5   15.6
6    7   19.8

> lapply(BOD,sum)

$Time
[1] 22

$demand
[1] 89

> lapply(BOD,mean)

$Time
[1] 3.666667

$demand
[1] 14.83333

> lapply(BOD,function(x) x*10)

$Time
[1] 10 20 30 40 50 70

$demand
[1]  83 103 190 160 156 198

legend() function adds a legend box to plot. It's expression is:

legend(x, y = NULL, legend, fill = NULL, col = par("col"),
       border = "black", lty, lwd, pch,
       angle = 45, density = NULL, bty = "o", bg = par("bg"),
       box.lwd = par("lwd"), box.lty = par("lty"), box.col = par("fg"),
       pt.bg = NA, cex = 1, pt.cex = cex, pt.lwd = lwd,
       xjust = 0, yjust = 1, x.intersp = 1, y.intersp = 1,
       adj = c(0, 0.5), text.width = NULL, text.col = par("col"),
       text.font = NULL, merge = do.lines && has.pch, trace = FALSE,
       plot = TRUE, ncol = 1, horiz = FALSE, title = NULL,
       inset = 0, xpd, title.col = text.col, title.adj = 0.5,
       seg.len = 2)

>x <- c(1.2,3.4,1.3,-2.1,5.6,2.3,3.2,2.4,2.1,1.8,1.7,2.2)
>y <- c(2.4,5.7,2.0,-3,13,5,6.2,4.8,4.2,3.5,3.7,5.2)
>plot(x,y,cex=.8,pch=1,xlab="x",ylab="y",col="black")

>x2 <- c(4.1,1.1,-2.3,-0.2,-1.2,2.3)
>y2 <- c(2.3,4.2,1.2,2.1,-2,4.3)
>points(x2,y2,cex=.8,pch=3,col="blue")

>legend(x=-2,y=12,c("sample","control"),cex=.8, 
        col=c("black","blue"),pch=c(1,3))

length() function gets or sets the length of a vector (list) or other objects.

Get vector length:

>x <- c(1,2,5,4,6,1,22,1)
>length(x)

[1] 8

>length(x) <- 4
>x

[1] 1 2 5 4

>y <- list(batch=3,label="Lung Cancer Patients", subtype=c("A","B","C"))
>y

$batch
[1] 3

$label
[1] "Lung Cancer Patients"

$subtype
[1] "A" "B" "C"

>is.list(y)

[1] TURE

>length(y)

[1] 3

>length(BOD)

[1] 2

>BOD

  Time demand
1    1    8.3
2    2   10.3
3    3   19.0
4    4   16.0
5    5   15.6
6    7   19.8

> length(BOD) <- 1
> BOD

$Time
[1] 1 2 3 4 5 7

> length(BOD) <- 3
> BOD

$Time
[1] 1 2 3 4 5 7

$demand
[1]  8.3 10.3 19.0 16.0 15.6 19.8

[[3]]
NULL

levels() function gets or sets the levels abbribute of a variable.
nlevels() function returns the number of levels of a variable.

levels(x)
levels(x) <- value
nlevels(x)

> x <- 3
> levels(x)

NULL

> x <- c(3,4,5,9)
> levels(x)

NULL

> x <- gl(2,4,5)
> x

[1] 1 1 1 1 2
Levels: 1 2

> levels(x)

[1] "1" "2"

> levels(x) <- c("sample","control")
> levels(x)

[1] "sample"  "control"

> x

[1] sample  sample  sample  sample  control
Levels: sample control

> x <- gl(2,4,5)
> x

[1] 1 1 1 1 2
Levels: 1 2

> nlevels(x)

[1] 2

library() and require() function load add-on packages.