#### Overview of this book

R Object-oriented Programming
Credits
www.PacktPub.com
Preface
Free Chapter
Data Types
Organizing Data
Saving Data and Printing Results
Calculating Probabilities and Random Numbers
Character and String Operations
Converting and Defining Time Variables
Basic Programming
S3 Classes
S4 Classes
Case Study – Simulation
Package Management
Index

## Discrete data types

One of the features of the R environment is the rich collection of data types that are available. Here, we briefly list some of the built-in data types that describe discrete data. The four data types discussed are the integer, logical, character, and factor data types. We also introduce the idea of a vector, which is the default data structure for any variable. A list of the commands discussed here is given in Table 2 and Table 3.

It should be noted that the default data type in R, for a number, is a double precision number. Strings can be interpreted in a variety of ways, usually as either a string or a factor. You should be careful to make sure that R is storing information in the format that you want, and it is important to double-check this important aspect of how data is tracked.

### Integer

The first discrete data type examined is the integer type. Values are 32-bit integers. In most circumstances, a number must be explicitly cast as being an integer, as the default type in R is a double precision number. There are a variety of commands used to cast integers as well as allocate space for integers. The `integer` command takes a number for an argument and will return a vector of integers whose length is given by the argument:

```> bubba <- integer(12)
> bubba
[1] 0 0 0 0 0 0 0 0 0 0 0 0
> bubba[1]
[1] 0
> bubba[2]
[1] 0
> bubba[[4]]
[1] 0
>  b[4] <- 15
> b
[1]  0  0  0 15  0  0  0  0  0  0  0  0
```

In the preceding example, a vector of twelve integers was defined. The default values are zero, and the individual entries in the vector are accessed using braces. The first entry in the vector has index `1`, so in this example, `bubba[1]` refers to the initial entry in the vector. Note that there are two ways to access an element in the vector: single versus double braces. For a vector, the two methods are nearly the same, but when we explore the use of lists as opposed to vectors, the meaning will change. In short, the double braces return objects of the same type as the elements within the vector, and the single braces return values of the same type as the variable itself. For example, using single braces on a list will return a list, while double braces may return a vector.

A number can be cast as an integer using the `as.integer` command. A variable's type can be checked using the `typeof` command. The `typeof` command indicates how R stores the object and is different from the `class` command, which is an attribute that you can change or query:

```> as.integer(13.2)
[1] 13
> thisNumber <- as.integer(8/3)
> typeof(thisNumber)
[1] "integer"
```

Note that a sequence of numbers can be automatically created using either the `:` operator or the `seq` command:

```> 1:5
[1] 1 2 3 4 5
> myNum <- as.integer(1:5)

> myNum[1]
[1] 1
> myNum[3]
[1] 3

> seq(4,11,by=2)
[1]  4  6  8 10
> otherNums <- seq(4,11,by=2)

> otherNums[3]
[1] 8
```

A common task is to determine whether or not a variable is of a certain type. For integers, the `is.integer` command is used to determine whether or not a variable has an integer type:

```> a <- 1.2
> typeof(a)
[1] "double"
> is.integer(a)
[1] FALSE

> a <- as.integer(1.2)
> typeof(a)
[1] "integer"
> is.integer(a)
[1] TRUE
```

### Logical

Logical data consists of variables that are either true or false. The words `TRUE` and `FALSE` are used to designate the two possible values of a logical variable. (The `TRUE` value can also be abbreviated to `T`, and the `FALSE` value can be abbreviated to `F`.) The basic commands associated with logical variables are similar to the commands for integers discussed in the previous subsection. The `logical` command is used to allocate a vector of Boolean values. In the following example, a logical vector of length 10 is created. The default value is `FALSE`, and the Boolean not operator is used to flip the values to evaluate to `TRUE`:

```> b <- logical(10)
> b
[1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
> b[3]
[1] FALSE
> !b
[1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE
> !b[5]
[1] TRUE
> typeof(b)
[1] "logical"
> mode(b)
[1] "logical"
> storage.mode(b)
[1] "logical"
>  b[3] <- TRUE
> b
[1] FALSE FALSE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
```

To cast a value to a logical type, you can use the `as.logical` command. Note that zero is mapped to a value of `FALSE` and other numbers are mapped to a value of `TRUE`:

```> a <- -1:1
> a
[1] -1  0  1
> as.logical(a)
[1]  TRUE FALSE  TRUE
```

To determine whether or not a value has a logical type, you use the `is.logical` command:

```> b <- logical(4)
> b
[1] FALSE FALSE FALSE FALSE
> is.logical(b)
[1] TRUE
```

The standard operators for logical operations are available, and a list of some of the more common operations is given in Table 1. Note that there is a difference between operations such as `&` and `&&`. A single `&` is used to perform an `and` operation on each pairwise element of two vectors, while the double `&&` returns a single logical result using only the first elements of the vectors:

```> l1 <- c(TRUE,FALSE)
> l2 <- c(TRUE,TRUE)
> l1&l1
[1]  TRUE FALSE
> l1&&l1
[1] TRUE
> l1|l2
[1] TRUE TRUE
> l1||l2
[1] TRUE
```

### Tip

You can download the example code files for all Packt books you have purchased from your account at http://www.packtpub.com. An additional source for the examples in this book can be found at https://github.com/KellyBlack/R-Object-Oriented-Programming. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

The following table shows various logical operators and their description:

Logical Operator

Description

`<`

Less than

`>`

Greater that

`<=`

Less than or equal to

`>=`

Greater than or equal to

`==`

Equal to

`!=`

Not equal to

`|`

Entrywise or

`||`

Or

`!`

Not

`&`

Entrywise and

`&&`

And

`xor(a,b)`

Exclusive or

Table 1 – list of operators for logical variables

#### Character

One common way to store information is to save data as characters or strings. Character data is defined using either single or double quotes:

```> a <- "hello"
> a
[1] "hello"
> b <- 'there'
> b
[1] "there"
> typeof(a)
[1] "character"
```

The `character` command can be used to allocate a vector of character-valued strings, as follows:

```> many <- character(3)
> many
[1] "" "" ""
> many[2] <- "this is the second"
> many[3] <- 'yo, third!'
> many[1] <- "and the first"
> many
[1] "and the first"      "this is the second" "yo, third!"
```

A value can be cast as a character using the `as.character` command, as follows:

```> a <- 3.0
> a
[1] 3
> b <- as.character(a)
> b
[1] "3"
```

Finally, the `is.character` command takes a single argument, and it returns a value of `TRUE` if the argument is a string:

```> a <- as.character(4.5)
> a
[1] "4.5"
> is.character(a)
[1] TRUE
```

#### Factors

Another common way to record data is to provide a discrete set of levels. For example, the results of an individual trial in an experiment may be denoted by a value of `a`, `b`, or `c`. Ordinal data of this kind is referred to as a factor in R. The commands and ideas are roughly parallel to the data types described previously. There are some subtle differences with factors, though. Factors are used to designate different levels and can be considered ordered or unordered. There are a large number of options, and it is wise to consult the help pages for factors using the `(help(factor))` command. One thing to note, though, is that the `typeof` command for a factor will return an integer.

Factors can be defined using the `factor` command, as follows:

```> lev <- factor(x=c("one","two","three","one"))
> lev
[1] one   two   three one
Levels: one three two
> levels(lev)
[1] "one"   "three" "two"
> sort(lev)
[1] one   one   two   three
Levels: one two three

>  lev <- factor(x=c("one","two","three","one"),levels=c("one","two","three"))
> lev
[1] one   two   three one
Levels: one two three
> levels(lev)
[1] "one"   "two"   "three"
> sort(lev)
[1] one   one   two   three
Levels: one two three
```

The techniques used to cast a variable to a factor or test whether a variable is a factor are similar to the previous examples. A variable can be cast as a factor using the `as.factor` command. Also, the `is.factor` command can be used to determine whether or not a variable has a type of factor.

### Continuous data types

The data types for continuous data types are given here. The double and complex data types are given. A list of the commands discussed here is given in Table 2 and Table 3.

#### Double

The default numeric data type in R is a double precision number. The commands are similar to those of the integer data type discussed previously. The `double` command can be used to allocate a vector of double precision numbers, and the numbers within the vector are accessed using braces:

```> d <- double(8)
> d
[1] 0 0 0 0 0 0 0 0
> typeof(d)
[1] "double"
> d[3] <- 17
> d
[1]  0  0 17  0  0  0  0  0
```

The techniques used to cast a variable to a double precision number and test whether a variable is a double precision number are similar to the examples seen previously. A variable can be cast as a double precision number using the `as.double` command. Also, to determine whether a variable is a double precision number, the `as.double` command can be used.

#### Complex

Arithmetic for complex numbers is supported in R, and most math functions will react properly when given a complex number. You can append `i` to the end of a number to force it to be the imaginary part of a complex number, as follows:

```> 1i
[1] 0+1i
> 1i*1i
[1] -1+0i
> z <- 3+2i
> z
[1] 3+2i
> z*z
[1] 5+12i
> Mod(z)
[1] 3.605551
> Re(z)
[1] 3
> Im(z)
[1] 2
> Arg(z)
[1] 0.5880026
> Conj(z)
[1] 3-2i
```

The `complex` command can also be used to define a vector of complex numbers. There are a number of options for the `complex` command, so a quick check of the help page, `(help(complex))`, is recommended:

```> z <- complex(3)
> z
[1] 0+0i 0+0i 0+0i
> typeof(z)
[1] "complex"
> z <- complex(real=c(1,2),imag=c(3,4))
> z
[1] 1+3i 2+4i
> Re(z)
[1] 1 2
```

The techniques to cast a variable to a complex number and to test whether or not a variable is a complex number are similar to the methods seen previously. A variable can be cast as complex using the `as.complex` command. Also, to test whether or not a variable is a complex number, the `as.complex` command can be used.

### Special data types

There are two other common data types that occur that are important. We will discuss these two data types and provide a note about objects. The two data types are `NA` and `NULL`. These are brief comments, as these are recurring topics that we will revisit many times.

The first data type is a constant, `NA`. This is a type used to indicate a missing value. It is a constant in R, and a variable can be tested using the `is.na` command, as follows:

```> n <- c(NA,2,3,NA,5)
> n
[1] NA  2  3 NA  5
> is.na(n)
[1]  TRUE FALSE FALSE  TRUE FALSE
> n[!is.na(n)]
[1] 2 3 5
```

Another special type is the `NULL` type. It has the same meaning as the `null` keyword in the C language. It is not an actual type but is used to determine whether or not an object exists:

```> a <- NULL
> typeof(a)
[1] "NULL"
```

Finally, we'll quickly explore the term `objects`. The variables that we defined in all of the preceding examples are treated as objects within the R environment. When we start writing functions and creating classes, it will be important to realize that they are treated like variables. The names used to assign variables are just a shortcut for R to determine where an object is located.

For example, the `complex` command is used to allocate a vector of complex values. The command is defined to be a set of instructions, and there is an object called `complex` that points to those instructions:

```> complex
function (length.out = 0L, real = numeric(), imaginary = numeric(),
modulus = 1, argument = 0)
{
if (missing(modulus) && missing(argument)) {
.Internal(complex(length.out, real, imaginary))
}
else {
n <- max(length.out, length(argument), length(modulus))
rep_len(modulus, n) * exp((0+1i) * rep_len(argument,
n))
}
}
<bytecode: 0x2489c80>
<environment: namespace:base>```

There is a difference between calling the `complex()`function and referring to the set of instructions located at `complex`.

#### Notes on the as and is functions

Two common tasks are to determine whether a variable is of a given type and to cast a variable to different types. The commands to determine whether a variable is of a given type generally start with the `is` prefix, and the commands to cast a variable to a different type generally start with the `as` prefix. The list of commands to determine whether a variable is of a given type are given in the following table:

Type to check

Command

Integer

`is.integer`

Logical

`is.logical`

Character

`is.character`

Factor

`is.factor`

Double

`is.double`

Complex

`is.complex`

NA

`is.NA`

List

`is.list`

Table 2 – commands to determine whether a variable is of a particular type

The commands used to cast a variable to a different type are given in Table 3. These commands take a single argument and return a variable of the given type. For example, the `as.character` command can be used to convert a number to a string.

The commands in the previous table are used to test what type a variable has. The following table provides the commands that are used to change a variable of one type to another type:

Type to convert to

Command

Integer

`as.integer`

Logical

`as.logical`

Character

`as.character`

Factor

`as.factor`

Double

`as.double`

Complex

`as.complex`

NA

`as.NA`

List

`as.list`

Table 3 – commands to cast a variable into a particular type