## R Array Assignment

## Data structures

This chapter summarises the most important data structures in base R. You’ve probably used many (if not all) of them before, but you may not have thought deeply about how they are interrelated. In this brief overview, I won’t discuss individual types in depth. Instead, I’ll show you how they fit together as a whole. If you need more details, you can find them in R’s documentation.

R’s base data structures can be organised by their dimensionality (1d, 2d, or nd) and whether they’re homogeneous (all contents must be of the same type) or heterogeneous (the contents can be of different types). This gives rise to the five data types most often used in data analysis:

1d | Atomic vector | List |

2d | Matrix | Data frame |

nd | Array |

Almost all other objects are built upon these foundations. In the OO field guide you’ll see how more complicated objects are built of these simple pieces. Note that R has no 0-dimensional, or scalar types. Individual numbers or strings, which you might think would be scalars, are actually vectors of length one.

Given an object, the best way to understand what data structures it’s composed of is to use . is short for structure and it gives a compact, human readable description of any R data structure.

##### Quiz

Take this short quiz to determine if you need to read this chapter. If the answers quickly come to mind, you can comfortably skip this chapter. You can check your answers in answers.

What are the three properties of a vector, other than its contents?

What are the four common types of atomic vectors? What are the two rare types?

What are attributes? How do you get them and set them?

How is a list different from an atomic vector? How is a matrix different from a data frame?

Can you have a list that is a matrix? Can a data frame have a column that is a matrix?

##### Outline

Vectors introduces you to atomic vectors and lists, R’s 1d data structures.

Attributes takes a small detour to discuss attributes, R’s flexible metadata specification. Here you’ll learn about factors, an important data structure created by setting attributes of an atomic vector.

Matrices and arrays introduces matrices and arrays, data structures for storing 2d and higher dimensional data.

Data frames teaches you about the data frame, the most important data structure for storing data in R. Data frames combine the behaviour of lists and matrices to make a structure ideally suited for the needs of statistical data.

## Vectors

The basic data structure in R is the vector. Vectors come in two flavours: atomic vectors and lists. They have three common properties:

- Type, , what it is.
- Length, , how many elements it contains.
- Attributes, , additional arbitrary metadata.

They differ in the types of their elements: all elements of an atomic vector must be the same type, whereas the elements of a list can have different types.

NB: does not test if an object is a vector. Instead it returns only if the object is a vector with no attributes apart from names. Use to test if an object is actually a vector.

### Atomic vectors

There are four common types of atomic vectors that I’ll discuss in detail: logical, integer, double (often called numeric), and character. There are two rare types that I will not discuss further: complex and raw.

Atomic vectors are usually created with , short for combine:

Atomic vectors are always flat, even if you nest ’s:

Missing values are specified with , which is a logical vector of length 1. will always be coerced to the correct type if used inside , or you can create s of a specific type with (a double vector), and .

#### Types and tests

Given a vector, you can determine its type with , or check if it’s a specific type with an “is” function: , , , , or, more generally, .

NB: is a general test for the “numberliness” of a vector and returns for both integer and double vectors. It is not a specific test for double vectors, which are often called numeric.

#### Coercion

All elements of an atomic vector must be the same type, so when you attempt to combine different types they will be **coerced** to the most flexible type. Types from least to most flexible are: logical, integer, double, and character.

For example, combining a character and an integer yields a character:

When a logical vector is coerced to an integer or double, becomes 1 and becomes 0. This is very useful in conjunction with and

Coercion often happens automatically. Most mathematical functions (, , , etc.) will coerce to a double or integer, and most logical operations (, , , etc) will coerce to a logical. You will usually get a warning message if the coercion might lose information. If confusion is likely, explicitly coerce with , , , or .

### Lists

Lists are different from atomic vectors because their elements can be of any type, including lists. You construct lists by using instead of :

Lists are sometimes called **recursive** vectors, because a list can contain other lists. This makes them fundamentally different from atomic vectors.

will combine several lists into one. If given a combination of atomic vectors and lists, will coerce the vectors to lists before combining them. Compare the results of and :

The a list is . You can test for a list with and coerce to a list with . You can turn a list into an atomic vector with . If the elements of a list have different types, uses the same coercion rules as .

Lists are used to build up many of the more complicated data structures in R. For example, both data frames (described in data frames) and linear models objects (as produced by ) are lists:

### Exercises

What are the six types of atomic vector? How does a list differ from an atomic vector?

What makes and fundamentally different to and ?

Test your knowledge of vector coercion rules by predicting the output of the following uses of :

Why do you need to use to convert a list to an atomic vector? Why doesn’t work?

Why is true? Why is true? Why is false?

Why is the default missing value, , a logical vector? What’s special about logical vectors? (Hint: think about .)

## Attributes

All objects can have arbitrary additional attributes, used to store metadata about the object. Attributes can be thought of as a named list (with unique names). Attributes can be accessed individually with or all at once (as a list) with .

The function returns a new object with modified attributes:

By default, most attributes are lost when modifying a vector:

The only attributes not lost are the three most important:

Names, a character vector giving each element a name, described in names.

Dimensions, used to turn vectors into matrices and arrays, described in matrices and arrays.

Class, used to implement the S3 object system, described in S3.

Each of these attributes has a specific accessor function to get and set values. When working with these attributes, use , , and , not , , and .

#### Names

You can name a vector in three ways:

When creating it: .

By modifying an existing vector in place: .

Or: .

- By creating a modified copy of a vector: .

Names don’t have to be unique. However, character subsetting, described in subsetting, is the most important reason to use names and it is most useful when the names are unique.

Not all elements of a vector need to have a name. If some names are missing when you create the vector, the names will be set to an empty string for those elements. If you modify the vector in place by setting some, but not all variable names, will return NA (more specifically, NA_character_) for them. If all names are missing, will return .

You can create a new vector without names using , or remove names in place with .

### Factors

One important use of attributes is to define factors. A factor is a vector that can contain only predefined values, and is used to store categorical data. Factors are built on top of integer vectors using two attributes: the , “factor”, which makes them behave differently from regular integer vectors, and the , which defines the set of allowed values.

Factors are useful when you know the possible values a variable may take, even if you don’t see all values in a given dataset. Using a factor instead of a character vector makes it obvious when some groups contain no observations:

Sometimes when a data frame is read directly from a file, a column you’d thought would produce a numeric vector instead produces a factor. This is caused by a non-numeric value in the column, often a missing value encoded in a special way like or . To remedy the situation, coerce the vector from a factor to a character vector, and then from a character to a double vector. (Be sure to check for missing values after this process.) Of course, a much better plan is to discover what caused the problem in the first place and fix that; using the argument to is often a good place to start.

Unfortunately, most data loading functions in R automatically convert character vectors to factors. This is suboptimal, because there’s no way for those functions to know the set of all possible levels or their optimal order. Instead, use the argument to suppress this behaviour, and then manually convert character vectors to factors using your knowledge of the data. A global option, , is available to control this behaviour, but I don’t recommend using it. Changing a global option may have unexpected consequences when combined with other code (either from packages, or code that you’re ing), and global options make code harder to understand because they increase the number of lines you need to read to understand how a single line of code will behave.

While factors look (and often behave) like character vectors, they are actually integers. Be careful when treating them like strings. Some string methods (like and ) will coerce factors to strings, while others (like ) will throw an error, and still others (like ) will use the underlying integer values. For this reason, it’s usually best to explicitly convert factors to character vectors if you need string-like behaviour. In early versions of R, there was a memory advantage to using factors instead of character vectors, but this is no longer the case.

### Exercises

An early draft used this code to illustrate :

But when you print that object you don’t see the comment attribute. Why? Is the attribute missing, or is there something else special about it? (Hint: try using help.)

What happens to a factor when you modify its levels?

What does this code do? How do and differ from ?

## Matrices and arrays

Adding a attribute to an atomic vector allows it to behave like a multi-dimensional **array**. A special case of the array is the **matrix**, which has two dimensions. Matrices are used commonly as part of the mathematical machinery of statistics. Arrays are much rarer, but worth being aware of.

Matrices and arrays are created with and , or by using the assignment form of :

and have high-dimensional generalisations:

generalises to and for matrices, and for arrays.

generalises to and for matrices, and , a list of character vectors, for arrays.

generalises to and for matrices, and to (provided by the package) for arrays. You can transpose a matrix with ; the generalised equivalent for arrays is .

You can test if an object is a matrix or array using and , or by looking at the length of the . and make it easy to turn an existing vector into a matrix or array.

Vectors are not the only 1-dimensional data structure. You can have matrices with a single row or single column, or arrays with a single dimension. They may print similarly, but will behave differently. The differences aren’t too important, but it’s useful to know they exist in case you get strange output from a function ( is a frequent offender). As always, use to reveal the differences.

While atomic vectors are most commonly turned into matrices, the dimension attribute can also be set on lists to make list-matrices or list-arrays:

These are relatively esoteric data structures, but can be useful if you want to arrange objects into a grid-like structure. For example, if you’re running models on a spatio-temporal grid, it might be natural to preserve the grid structure by storing the models in a 3d array.

### Exercises

What does return when applied to a vector?

If is , what will return?

How would you describe the following three objects? What makes them different to ?

## Data frames

A data frame is the most common way of storing data in R, and if used systematically makes data analysis easier. Under the hood, a data frame is a list of equal-length vectors. This makes it a 2-dimensional structure, so it shares properties of both the matrix and the list. This means that a data frame has , , and , although and are the same thing. The of a data frame is the length of the underlying list and so is the same as ; gives the number of rows.

As described in subsetting, you can subset a data frame like a 1d structure (where it behaves like a list), or a 2d structure (where it behaves like a matrix).

### Creation

You create a data frame using , which takes named vectors as input:

Beware ’s default behaviour which turns strings into factors. Use to suppress this behaviour:

### Testing and coercion

Because a is an S3 class, its type reflects the underlying vector used to build it: the list. To check if an object is a data frame, use or test explicitly with :

You can coerce an object to a data frame with :

A vector will create a one-column data frame.

A list will create one column for each element; it’s an error if they’re not all the same length.

A matrix will create a data frame with the same number of columns and rows as the matrix.

### Combining data frames

You can combine data frames using and :

When combining column-wise, the number of rows must match, but row names are ignored. When combining row-wise, both the number and names of columns must match. Use to combine data frames that don’t have the same columns.

It’s a common mistake to try and create a data frame by ing vectors together. This doesn’t work because will create a matrix unless one of the arguments is already a data frame. Instead use directly:

The conversion rules for are complicated and best avoided by ensuring all inputs are of the same type.

### Special columns

Since a data frame is a list of vectors, it is possible for a data frame to have a column that is a list:

However, when a list is given to , it tries to put each item of the list into its own column, so this fails:

A workaround is to use , which causes to treat the list as one unit:

adds the class to its input, but this can usually be safely ignored.

Similarly, it’s also possible to have a column of a data frame that’s a matrix or array, as long as the number of rows matches the data frame:

Use list and array columns with caution: many functions that work with data frames assume that all columns are atomic vectors.

### Exercises

What attributes does a data frame possess?

What does do when applied to a data frame with columns of different types?

Can you have a data frame with 0 rows? What about 0 columns?

## Answers

The three properties of a vector are type, length, and attributes.

The four common types of atomic vector are logical, integer, double (sometimes called numeric), and character. The two rarer types are complex and raw.

Attributes allow you to associate arbitrary additional metadata to any object. You can get and set individual attributes with and ; or get and set all attributes at once with .

The elements of a list can be any type (even a list); the elements of an atomic vector are all of the same type. Similarly, every element of a matrix must be the same type; in a data frame, the different columns can have different types.

You can make “list-array” by assigning dimensions to a list. You can make a matrix a column of a data frame with , or using when creating a new data frame .

## An Introduction to R

## Table of Contents

## An Introduction to R

This is an introduction to R (“GNU S”), a language and environment for statistical computing and graphics. R is similar to the award-winning^{1} S system, which was developed at Bell Laboratories by John Chambers et al. It provides a wide variety of statistical and graphical techniques (linear and nonlinear modelling, statistical tests, time series analysis, classification, clustering, ...).

This manual provides information on data types, programming elements, statistical modelling and graphics.

This manual is for R, version 3.4.3 (2017-11-30).

Copyright © 1990 W. N. Venables

Copyright © 1992 W. N. Venables & D. M. Smith

Copyright © 1997 R. Gentleman & R. Ihaka

Copyright © 1997, 1998 M. Maechler

Copyright © 1999–2016 R Core Team

Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.

Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the R Core Team.

## Preface

This introduction to R is derived from an original set of notes describing the S and S-PLUS environments written in 1990–2 by Bill Venables and David M. Smith when at the University of Adelaide. We have made a number of small changes to reflect differences between the R and S programs, and expanded some of the material.

We would like to extend warm thanks to Bill Venables (and David Smith) for granting permission to distribute this modified version of the notes in this way, and for being a supporter of R from way back.

Comments and corrections are always welcome. Please address email correspondence to R-core@R-project.org.

#### Suggestions to the reader

Most R novices will start with the introductory session in Appendix A. This should give some familiarity with the style of R sessions and more importantly some instant feedback on what actually happens.

Many users will come to R mainly for its graphical facilities. See Graphics, which can be read at almost any time and need not wait until all the preceding sections have been digested.

## 1 Introduction and preliminaries

### 1.1 The R environment

R is an integrated suite of software facilities for data manipulation, calculation and graphical display. Among other things it has

- an effective data handling and storage facility,
- a suite of operators for calculations on arrays, in particular matrices,
- a large, coherent, integrated collection of intermediate tools for data analysis,
- graphical facilities for data analysis and display either directly at the computer or on hardcopy, and
- a well developed, simple and effective programming language (called ‘S’) which includes conditionals, loops, user defined recursive functions and input and output facilities. (Indeed most of the system supplied functions are themselves written in the S language.)

The term “environment” is intended to characterize it as a fully planned and coherent system, rather than an incremental accretion of very specific and inflexible tools, as is frequently the case with other data analysis software.

R is very much a vehicle for newly developing methods of interactive data analysis. It has developed rapidly, and has been extended by a large collection of *packages*. However, most programs written in R are essentially ephemeral, written for a single piece of data analysis.

### 1.2 Related software and documentation

R can be regarded as an implementation of the S language which was developed at Bell Laboratories by Rick Becker, John Chambers and Allan Wilks, and also forms the basis of the S-PLUS systems.

The evolution of the S language is characterized by four books by John Chambers and coauthors. For R, the basic reference is *The New S Language: A Programming Environment for Data Analysis and Graphics* by Richard A. Becker, John M. Chambers and Allan R. Wilks. The new features of the 1991 release of S are covered in *Statistical Models in S* edited by John M. Chambers and Trevor J. Hastie. The formal methods and classes of the **methods** package are based on those described in *Programming with Data* by John M. Chambers. See References, for precise references.

There are now a number of books which describe how to use R for data analysis and statistics, and documentation for S/S-PLUS can typically be used with R, keeping the differences between the S implementations in mind. See What documentation exists for R? in The R statistical system FAQ.

### 1.3 R and statistics

Our introduction to the R environment did not mention *statistics*, yet many people use R as a statistics system. We prefer to think of it of an environment within which many classical and modern statistical techniques have been implemented. A few of these are built into the base R environment, but many are supplied as *packages*. There are about 25 packages supplied with R (called “standard” and “recommended” packages) and many more are available through the family of Internet sites (via https://CRAN.R-project.org) and elsewhere. More details on packages are given later (see Packages).

Most classical statistics and much of the latest methodology is available for use with R, but users may need to be prepared to do a little work to find it.

There is an important difference in philosophy between S (and hence R) and the other main statistical systems. In S a statistical analysis is normally done as a series of steps, with intermediate results being stored in objects. Thus whereas SAS and SPSS will give copious output from a regression or discriminant analysis, R will give minimal output and store the results in a fit object for subsequent interrogation by further R functions.

### 1.4 R and the window system

The most convenient way to use R is at a graphics workstation running a windowing system. This guide is aimed at users who have this facility. In particular we will occasionally refer to the use of R on an X window system although the vast bulk of what is said applies generally to any implementation of the R environment.

Most users will find it necessary to interact directly with the operating system on their computer from time to time. In this guide, we mainly discuss interaction with the operating system on UNIX machines. If you are running R under Windows or macOS you will need to make some small adjustments.

Setting up a workstation to take full advantage of the customizable features of R is a straightforward if somewhat tedious procedure, and will not be considered further here. Users in difficulty should seek local expert help.

### 1.5 Using R interactively

When you use the R program it issues a prompt when it expects input commands. The default prompt is ‘’, which on UNIX might be the same as the shell prompt, and so it may appear that nothing is happening. However, as we shall see, it is easy to change to a different R prompt if you wish. We will assume that the UNIX shell prompt is ‘’.

In using R under UNIX the suggested procedure for the first occasion is as follows:

- Create a separate sub-directory, say , to hold data files on which you will use R for this problem. This will be the working directory whenever you use R for this particular problem.
- Start the R program with the command
- At this point R commands may be issued (see later).
- To quit the R program the command is
At this point you will be asked whether you want to save the data from your R session. On some systems this will bring up a dialog box, and on others you will receive a text prompt to which you can respond , or (a single letter abbreviation will do) to save the data before quitting, quit without saving, or return to the R session. Data which is saved will be available in future R sessions.

Further R sessions are simple.

- Make the working directory and start the program as before:
- Use the R program, terminating with the command at the end of the session.

To use R under Windows the procedure to follow is basically the same. Create a folder as the working directory, and set that in the field in your R shortcut. Then launch R by double clicking on the icon.

### 1.6 An introductory session

Readers wishing to get a feel for R at a computer before proceeding are strongly advised to work through the introductory session given in A sample session.

### 1.7 Getting help with functions and features

R has an inbuilt help facility similar to the facility of UNIX. To get more information on any specific named function, for example , the command is

An alternative is

For a feature specified by special characters, the argument must be enclosed in double or single quotes, making it a “character string”: This is also necessary for a few words with syntactic meaning including , and .

Either form of quote mark may be used to escape the other, as in the string . Our convention is to use double quote marks for preference.

On most R installations help is available in format by running

which will launch a Web browser that allows the help pages to be browsed with hyperlinks. On UNIX, subsequent help requests are sent to the -based help system. The ‘Search Engine and Keywords’ link in the page loaded by is particularly useful as it is contains a high-level concept list which searches though available functions. It can be a great way to get your bearings quickly and to understand the breadth of what R has to offer.

The command (alternatively ) allows searching for help in various ways. For example,

Try for details and more examples.

The examples on a help topic can normally be run by

Windows versions of R have other optional help systems: use

for further details.

### 1.8 R commands, case sensitivity, etc.

Technically R is an *expression language* with a very simple syntax. It is *case sensitive* as are most UNIX based packages, so and are different symbols and would refer to different variables. The set of symbols which can be used in R names depends on the operating system and country within which R is being run (technically on the *locale* in use). Normally all alphanumeric symbols are allowed^{2} (and in some countries this includes accented letters) plus ‘’ and ‘’, with the restriction that a name must start with ‘’ or a letter, and if it starts with ‘’ the second character must not be a digit. Names are effectively unlimited in length.

Elementary commands consist of either *expressions* or *assignments*. If an expression is given as a command, it is evaluated, printed (unless specifically made invisible), and the value is lost. An assignment also evaluates an expression and passes the value to a variable but the result is not automatically printed.

Commands are separated either by a semi-colon (‘’), or by a newline. Elementary commands can be grouped together into one compound expression by braces (‘’ and ‘’). *Comments* can be put almost^{3} anywhere, starting with a hashmark (‘’), everything to the end of the line is a comment.

If a command is not complete at the end of a line, R will give a different prompt, by default

on second and subsequent lines and continue to read input until the command is syntactically complete. This prompt may be changed by the user. We will generally omit the continuation prompt and indicate continuation by simple indenting.

Command lines entered at the console are limited^{4} to about 4095 bytes (not characters).

### 1.9 Recall and correction of previous commands

Under many versions of UNIX and on Windows, R provides a mechanism for recalling and re-executing previous commands. The vertical arrow keys on the keyboard can be used to scroll forward and backward through a *command history*. Once a command is located in this way, the cursor can be moved within the command using the horizontal arrow keys, and characters can be removed with the key or added with the other keys. More details are provided later: see The command-line editor.

The recall and editing capabilities under UNIX are highly customizable. You can find out how to do this by reading the manual entry for the **readline** library.

Alternatively, the Emacs text editor provides more general support mechanisms (via , *Emacs Speaks Statistics*) for working interactively with R. See R and Emacs in The R statistical system FAQ.

### 1.10 Executing commands from or diverting output to a file

If commands^{5} are stored in an external file, say in the working directory , they may be executed at any time in an R session with the command

For Windows **Source** is also available on the **File** menu. The function ,

will divert all subsequent output from the console to an external file, . The command

restores it to the console once again.

### 1.11 Data permanency and removing objects

The entities that R creates and manipulates are known as *objects*. These may be variables, arrays of numbers, character strings, functions, or more general structures built from such components.

During an R session, objects are created and stored by name (we discuss this process in the next session). The R command

(alternatively, ) can be used to display the names of (most of) the objects which are currently stored within R. The collection of objects currently stored is called the *workspace*.

To remove objects the function is available:

All objects created during an R session can be stored permanently in a file for use in future R sessions. At the end of each R session you are given the opportunity to save all the currently available objects. If you indicate that you want to do this, the objects are written to a file called ^{6} in the current directory, and the command lines used in the session are saved to a file called .

When R is started at later time from the same directory it reloads the workspace from this file. At the same time the associated commands history is reloaded.

It is recommended that you should use separate working directories for analyses conducted with R. It is quite common for objects with names and to be created during an analysis. Names like this are often meaningful in the context of a single analysis, but it can be quite hard to decide what they might be when the several analyses have been conducted in the same directory.

## 2 Simple manipulations; numbers and vectors

### 2.1 Vectors and assignment

R operates on named *data structures*. The simplest such structure is the numeric *vector*, which is a single entity consisting of an ordered collection of numbers. To set up a vector named , say, consisting of five numbers, namely 10.4, 5.6, 3.1, 6.4 and 21.7, use the R command

This is an *assignment* statement using the *function* which in this context can take an arbitrary number of vector *arguments* and whose value is a vector got by concatenating its arguments end to end.^{7}

A number occurring by itself in an expression is taken as a vector of length one.

Notice that the assignment operator (‘’), which consists of the two characters ‘’ (“less than”) and ‘’ (“minus”) occurring strictly side-by-side and it ‘points’ to the object receiving the value of the expression. In most contexts the ‘’ operator can be used as an alternative.

Assignment can also be made using the function . An equivalent way of making the same assignment as above is with:

The usual operator, , can be thought of as a syntactic short-cut to this.

Assignments can also be made in the other direction, using the obvious change in the assignment operator. So the same assignment could be made using

If an expression is used as a complete command, the value is printed *and lost*^{8}. So now if we were to use the command

the reciprocals of the five values would be printed at the terminal (and the value of , of course, unchanged).

The further assignment

would create a vector with 11 entries consisting of two copies of with a zero in the middle place.

### 2.2 Vector arithmetic

Vectors can be used in arithmetic expressions, in which case the operations are performed element by element. Vectors occurring in the same expression need not all be of the same length. If they are not, the value of the expression is a vector with the same length as the longest vector which occurs in the expression. Shorter vectors in the expression are *recycled* as often as need be (perhaps fractionally) until they match the length of the longest vector. In particular a constant is simply repeated. So with the above assignments the command

generates a new vector of length 11 constructed by adding together, element by element, repeated 2.2 times, repeated just once, and repeated 11 times.

The elementary arithmetic operators are the usual , , , and for raising to a power. In addition all of the common arithmetic functions are available. , , , , , , and so on, all have their usual meaning. and select the largest and smallest elements of a vector respectively. is a function whose value is a vector of length two, namely . is the number of elements in , gives the total of the elements in , and their product.

Two statistical functions are which calculates the sample mean, which is the same as , and which gives

or sample variance. If the argument to is an *n*-by-*p* matrix the value is a *p*-by-*p* sample covariance matrix got by regarding the rows as independent *p*-variate sample vectors.

returns a vector of the same size as with the elements arranged in increasing order; however there are other more flexible sorting facilities available (see or which produce a permutation to do the sorting).

Note that and select the largest and smallest values in their arguments, even if they are given several vectors. The *parallel* maximum and minimum functions and return a vector (of length equal to their longest argument) that contains in each element the largest (smallest) element in that position in any of the input vectors.

For most purposes the user will not be concerned if the “numbers” in a numeric vector are integers, reals or even complex. Internally calculations are done as double precision real numbers, or double precision complex numbers if the input data are complex.

To work with complex numbers, supply an explicit complex part. Thus

will give and a warning, but

will do the computations as complex numbers.

### 2.3 Generating regular sequences

R has a number of facilities for generating commonly used sequences of numbers. For example is the vector . The colon operator has high priority within an expression, so, for example is the vector . Put and compare the sequences and .

The construction may be used to generate a sequence backwards.

The function is a more general facility for generating sequences. It has five arguments, only some of which may be specified in any one call. The first two arguments, if given, specify the beginning and end of the sequence, and if these are the only two arguments given the result is the same as the colon operator. That is is the same vector as .

Arguments to , and to many other R functions, can also be given in named form, in which case the order in which they appear is irrelevant. The first two arguments may be named and ; thus , and are all the same as . The next two arguments to may be named and , which specify a step size and a length for the sequence respectively. If neither of these is given, the default is assumed.

For example

generates in the vector . Similarly

generates the same vector in .

The fifth argument may be named , which is normally used as the only argument to create the sequence , or the empty sequence if the vector is empty (as it can be).

A related function is which can be used for replicating an object in various complicated ways. The simplest form is

which will put five copies of end-to-end in . Another useful version is

which repeats each element of five times before moving on to the next.

### 2.4 Logical vectors

As well as numerical vectors, R allows manipulation of logical quantities. The elements of a logical vector can have the values , , and (for “not available”, see below). The first two are often abbreviated as and , respectively. Note however that and are just variables which are set to and by default, but are not reserved words and hence can be overwritten by the user. Hence, you should always use and .

Logical vectors are generated by *conditions*. For example

sets as a vector of the same length as with values corresponding to elements of where the condition is *not* met and where it is.

The logical operators are , , , , for exact equality and for inequality. In addition if and are logical expressions, then is their intersection (*“and”*), is their union (*“or”*), and is the negation of .

Logical vectors may be used in ordinary arithmetic, in which case they are *coerced* into numeric vectors, becoming and becoming . However there are situations where logical vectors and their coerced numeric counterparts are not equivalent, for example see the next subsection.

### 2.5 Missing values

In some cases the components of a vector may not be completely known. When an element or value is “not available” or a “missing value” in the statistical sense, a place within a vector may be reserved for it by assigning it the special value . In general any operation on an becomes an . The motivation for this rule is simply that if the specification of an operation is incomplete, the result cannot be known and hence is not available.

The function gives a logical vector of the same size as with value if and only if the corresponding element in is .

Notice that the logical expression is quite different from since is not really a value but a marker for a quantity that is not available. Thus is a vector of the same length as *all* of whose values are as the logical expression itself is incomplete and hence undecidable.

Note that there is a second kind of “missing” values which are produced by numerical computation, the so-called *Not a Number*, , values. Examples are

or

which both give since the result cannot be defined sensibly.

In summary, is *both* for and values. To differentiate these, is only for s.

Missing values are sometimes printed as when character vectors are printed without quotes.

### 2.6 Character vectors

Character quantities and character vectors are used frequently in R, for example as plot labels. Where needed they are denoted by a sequence of characters delimited by the double quote character, e.g., , .

Character strings are entered using either matching double () or single () quotes, but are printed using double quotes (or sometimes without quotes). They use C-style escape sequences, using as the escape character, so is entered and printed as , and inside double quotes is entered as . Other useful escape sequences are , newline, , tab and , backspace—see for a full list.

Character vectors may be concatenated into a vector by the function; examples of their use will emerge frequently.

The function takes an arbitrary number of arguments and concatenates them one by one into character strings. Any numbers given among the arguments are coerced into character strings in the evident way, that is, in the same way they would be if they were printed. The arguments are by default separated in the result by a single blank character, but this can be changed by the named argument, , which changes it to , possibly empty.

For example

makes into the character vector

Note particularly that recycling of short lists takes place here too; thus is repeated 5 times to match the sequence . ^{9}

### 2.7 Index vectors; selecting and modifying subsets of a data set

Subsets of the elements of a vector may be selected by appending to the name of the vector an *index vector* in square brackets. More generally any expression that evaluates to a vector may have subsets of its elements similarly selected by appending an index vector in square brackets immediately after the expression.

Such index vectors can be any of four distinct types.

**A logical vector**. In this case the index vector is recycled to the same length as the vector from which elements are to be selected. Values corresponding to in the index vector are selected and those corresponding to are omitted. For example> y <- x[!is.na(x)]creates (or re-creates) an object which will contain the non-missing values of , in the same order. Note that if has missing values, will be shorter than . Also

> (x+1)[(!is.na(x)) & x>0] -> zcreates an object and places in it the values of the vector for which the corresponding value in was both non-missing and positive.

**A vector of positive integral quantities**. In this case the values in the index vector must lie in the set {1, 2, …, }. The corresponding elements of the vector are selected and concatenated,*in that order*, in the result. The index vector can be of any length and the result is of the same length as the index vector. For example is the sixth component of andselects the first 10 elements of (assuming is not less than 10). Also

> c("x","y")[rep(c(1,2,2,1), times=4)](an admittedly unlikely thing to do) produces a character vector of length 16 consisting of repeated four times.

**A vector of negative integral quantities**. Such an index vector specifies the values to be*excluded*rather than included. Thusgives all but the first five elements of .

**A vector of character strings**. This possibility only applies where an object has a attribute to identify its components. In this case a sub-vector of the names vector may be used in the same way as the positive integral labels in item 2 further above.> fruit <- c(5, 10, 1, 20) > names(fruit) <- c("orange", "banana", "apple", "peach") > lunch <- fruit[c("apple","orange")]The advantage is that alphanumeric

*names*are often easier to remember than*numeric indices*. This option is particularly useful in connection with data frames, as we shall see later.

An indexed expression can also appear on the receiving end of an assignment, in which case the assignment operation is performed *only on those elements of the vector*. The expression must be of the form as having an arbitrary expression in place of the vector name does not make much sense here.

For example

replaces any missing values in by zeros and

has the same effect as

### 2.8 Other types of objects

Vectors are the most important type of object in R, but there are several others which we will meet more formally in later sections.

*matrices*or more generally*arrays*are multi-dimensional generalizations of vectors. In fact, they*are*vectors that can be indexed by two or more indices and will be printed in special ways. See Arrays and matrices.*factors*provide compact ways to handle categorical data. See Factors.*lists*are a general form of vector in which the various elements need not be of the same type, and are often themselves vectors or lists. Lists provide a convenient way to return the results of a statistical computation. See Lists.*data frames*are matrix-like structures, in which the columns can be of different types. Think of data frames as ‘data matrices’ with one row per observational unit but with (possibly) both numerical and categorical variables. Many experiments are best described by data frames: the treatments are categorical but the response is numeric. See Data frames.*functions*are themselves objects in R which can be stored in the project’s workspace. This provides a simple and convenient way to extend R. See Writing your own functions.

## 3 Objects, their modes and attributes

### 3.1 Intrinsic attributes: mode and length

The entities R operates on are technically known as *objects*. Examples are vectors of numeric (real) or complex values, vectors of logical values and vectors of character strings. These are known as “atomic” structures since their components are all of the same type, or *mode*, namely *numeric*^{10}, *complex*, *logical*, *character* and *raw*.

Vectors must have their values *all of the same mode*. Thus any given vector must be unambiguously either *logical*, *numeric*, *complex*, *character* or *raw*. (The only apparent exception to this rule is the special “value” listed as for quantities not available, but in fact there are several types of ). Note that a vector can be empty and still have a mode. For example the empty character string vector is listed as and the empty numeric vector as .

R also operates on objects called *lists*, which are of mode *list*. These are ordered sequences of objects which individually can be of any mode. *lists* are known as “recursive” rather than atomic structures since their components can themselves be lists in their own right.

The other recursive structures are those of mode *function* and *expression*. Functions are the objects that form part of the R system along with similar user written functions, which we discuss in some detail later. Expressions as objects form an advanced part of R which will not be discussed in this guide, except indirectly when we discuss *formulae* used with modeling in R.

By the *mode* of an object we mean the basic type of its fundamental constituents. This is a special case of a “property” of an object. Another property of every object is its *length*. The functions and can be used to find out the mode and length of any defined structure ^{11}.

Further properties of an object are usually provided by , see Getting and setting attributes. Because of this, *mode* and *length* are also called “intrinsic attributes” of an object.

For example, if is a complex vector of length 100, then in an expression is the character string and is .

R caters for changes of mode almost anywhere it could be considered sensible to do so, (and a few where it might not be). For example with

we could put

after which is the character vector . A further *coercion*, or change of mode, reconstructs the numerical vector again:

Now and are the same.^{12} There is a large collection of functions of the form for either coercion from one mode to another, or for investing an object with some other attribute it may not already possess. The reader should consult the different help files to become familiar with them.

### 3.2 Changing the length of an object

An “empty” object may still have a mode. For example

makes an empty vector structure of mode numeric. Similarly is a empty character vector, and so on. Once an object of any size has been created, new components may be added to it simply by giving it an index value outside its previous range. Thus

now makes a vector of length 3, (the first two components of which are at this point both ). This applies to any structure at all, provided the mode of the additional component(s) agrees with the mode of the object in the first place.

This automatic adjustment of lengths of an object is used often, for example in the function for input. (see The scan() function.)

Conversely to truncate the size of an object requires only an assignment to do so. Hence if is an object of length 10, then

makes it an object of length 5 consisting of just the former components with even index. (The old indices are not retained, of course.) We can then retain just the first three values by

and vectors can be extended (by missing values) in the same way.

### 3.3 Getting and setting attributes

The function returns a list of all the non-intrinsic attributes currently defined for that object. The function can be used to select a specific attribute. These functions are rarely used, except in rather special circumstances when some new attribute is being created for some particular purpose, for example to associate a creation date or an operator with an R object. The concept, however, is very important.

Some care should be exercised when assigning or deleting attributes since they are an integral part of the object system used in R.

When it is used on the left hand side of an assignment it can be used either to associate a new attribute with or to change an existing one. For example

allows R to treat as if it were a 10-by-10 matrix.

### 3.4 The class of an object

All objects in R have a *class*, reported by the function . For simple vectors this is just the mode, for example , , or , but , , and are other possible values.

A special attribute known as the *class* of the object is used to allow for an object-oriented style^{13} of programming in R. For example if an object has class , it will be printed in a certain way, the function will display it graphically in a certain way, and other so-called generic functions such as will react to it as an argument in a way sensitive to its class.

To remove temporarily the effects of class, use the function . For example if has the class then

will print it in data frame form, which is rather like a matrix, whereas

will print it as an ordinary list. Only in rather special situations do you need to use this facility, but one is when you are learning to come to terms with the idea of class and generic functions.

Generic functions and classes will be discussed further in Object orientation, but only briefly.

## 4 Ordered and unordered factors

A *factor* is a vector object used to specify a discrete classification (grouping) of the components of other vectors of the same length. R provides both *ordered* and *unordered* factors. While the “real” application of factors is with model formulae (see Contrasts), we here look at a specific example.

### 4.1 A specific example

Suppose, for example, we have a sample of 30 tax accountants from all the states and territories of Australia^{14} and their individual state of origin is specified by a character vector of state mnemonics as

Notice that in the case of a character vector, “sorted” means sorted in alphabetical order.

A *factor* is similarly created using the function:

The function handles factors slightly differently from other objects:

To find out the levels of a factor the function can be used.

### 4.2 The function and ragged arrays

To continue the previous example, suppose we have the incomes of the same tax accountants in another vector (in suitably large units of money)

To calculate the sample mean income for each state we can now use the special function :

giving a means vector with the components labelled by the levels

The function is used to apply a function, here , to each group of components of the first argument, here , defined by the levels of the second component, here ^{15}, as if they were separate vector structures. The result is a structure of the same length as the levels attribute of the factor containing the results. The reader should consult the help document for more details.

Suppose further we needed to calculate the standard errors of the state income means. To do this we need to write an R function to calculate the standard error for any given vector. Since there is an builtin function to calculate the sample variance, such a function is a very simple one liner, specified by the assignment:

(Writing functions will be considered later in Writing your own functions. Note that R’s a builtin function is something different.) After this assignment, the standard errors are calculated by

and the values calculated are then

As an exercise you may care to find the usual 95% confidence limits for the state mean incomes. To do this you could use once more with the function to find the sample sizes, and the function to find the percentage points of the appropriate *t*-distributions. (You could also investigate R’s facilities for *t*-tests.)

The function can also be used to handle more complicated indexing of a vector by multiple categories. For example, we might wish to split the tax accountants by both state and sex. However in this simple instance (just one factor) what happens can be thought of as follows. The values in the vector are collected into groups corresponding to the distinct entries in the factor. The function is then applied to each of these groups individually. The value is a vector of function results, labelled by the attribute of the factor.

The combination of a vector and a labelling factor is an example of what is sometimes called a *ragged array*

## Leave a Comment

(0 Comments)