Chapter 1 The R environment
Last updated: 2021-01-16 22:24:15
Our aims in this chapter are:
- Introduce the main advantages and properties of programming
- Introduce the R environment
- Learn to write and execute basic expressions in R
1.1.1 Why is programming necessary?
In this section, we are going to demontrate the way that programming differs from Graphical User Interfaces (GUI), and its advantages, through two examples. The first example (Section 184.108.40.206) shows how the graphical interface hides essential details about the data we are working with, and ways to interact with them. The second example (Section 220.127.116.11) is similar, but related to spatial data—it shows how a seemingly simple operation is in fact complex when working with a graphical interface, but it is made simple through programming.
18.104.22.168 Example 1: A CSV file
Does the icon shown in Figure 1.1 refer to a Microsoft Excel spreadsheet?
The file has an Excel icon, and it opens in Excel on double-click (Figure 1.2).
However, this is in fact a plain-text file in the Comma Separated Values (CSV) format. A CSV file can be opened in various other software, such as Notepad (Figure 1.3), and not just in Excel.
This example demonstrates how the graphical interface “protects” us from the technical details of the files we are dealing with:
- Hiding the
- Displaying an Excel icon
- Automatically opening the file in Excel
Is this a bad thing? Often, it is:
- We can be unaware of the fact that the file can be opened in software other than Excel
- In general—the “ordinary” interaction with the computer is limited to clicking on links, selecting from menus and filling dialog boxes
- The latter approach suggests there are “boundaries” set by the computer interface for the user who wishes to accomplish a given task
- Of course the opposite is true—the user has full control, and can tell the computer exactly what he wants to do
22.214.171.124 Example 2: Changing a raster value
For the next example, suppose that we have a raster, such as the
rainfall.tif raster (Figure 1.4) of average annual rainfall in Israel. How can we change the value of a particular raster cell, such as the
[120, 120] cell in that raster? The operation may seem trivial. However, turns out there is no simple way to do it in traditional GIS software, since they do not provide straightforward methods to access (and modify) cell values by row/column index.
For example, using the GUI of ArcGIS, to change the value of an individual pixel we would have to go through the following steps:
- Open the raster with “Add Data”
- Convert the raster to points (Figure 1.5)
- Calculate row and column indices
- Locate the point we want to change and edit its attribute
- Convert the points to back to a raster, using the same extent and resolution and setting a “snap raster”
- Export the raster
In R, the process is much more straightforward:
- Loading the
- Reading the
- Assigning a new value to the
- Writing the raster to disk
It is worth mentioning that an analogous workflow exists in Python:
1.1.2 What is programming?
A computer program is a sequence of text instructions that can be “understood” by a computer and executed. A programming language is a machine-readable artificial language designed to express computations that can be performed by a computer. Programming is the preferred way for giving instructions to the computer, because that way:
- we break free from the limitations of the graphical interface, and are able to perform tasks that are unfeasible or even impossible, and
- we can keep the code for editing and re-use in the future, and as a reminder to ourselves of what we did in the past, and share a precise record of our analysis with others, making our results reproducible.
1.1.3 Computer hardware
When learning programming in R, at times we will refer to specific components of the computer hardware to describe what is going on “behind the scenes”. Here are the main computer hardware components (Figure 1.1.3):
- The Central Processing Unit (CPU) performs (simple) calculations very fast
- The Random Access Memory (RAM) is a short-term fast memory
- Mass Storage (e.g., hard drive) is long-term and high-capacity slow memory
- A Keyboard is an example of an input device
- A Screen is an example of an output device
Next, we introduce four central concepts of programming in general, and programming in R in particular: abstraction (Section 1.1.4), execution models (Section 1.1.4), object-oriented programming (Section 1.1.5) and inheritance (Section 1.1.6).
1.1.4 Abstraction and execution models
Programming languages differ in two main aspects: their level of abstraction and their execution models. Abstraction is the presentation of data and instructions which hide implementation detail. Abstraction is what lets the programmer focus on the task at hand, ignoring the small technical details (Figure 1.7).
Low-level programming languages provide little or no abstraction. The advantage of low-level programming languages is their efficient memory use and therefore fast execution. Their disadvantage is the languages are difficult to use, because of the many technical details that the programmer needs to know.
High-level programming languages provide more abstraction and automatically handle various aspects, such as memory use. The advantage of high-level languages is that they are more “understandable” and easier to use. The disadvantage is that high-level languages can be less efficient and therefore slower.
For most practical purposes, the convenience working with high-level languages greatly outweights their somewhat lower performance in terms of speed. This is why high-level languages are more widely used. The R language, which we are using in this book, is a high-level programming language.
Execution models are systems for execution of programs written in a given programming language. In compiled execution models, before being executed the code needs to be compiled into executable machine code. In compiled execution models, the code is first translated to an executable file (Figure 1.8). Subsequently, the executable file can then be run (Figure 1.9). In interpreted execution models, the code can be run directly, using the interpreter (Figure 1.10). The advantage of the interpretation approach is that it is easier to develop and use the language. The disadvantage, again, is lower efficiency.
Just like with abstraction levels, the convenience of working with interpreted languages usually outweights the gain in performance of compiled languages. Therefore, the former are preferable for most practical purposes.
R—along with Python, and many other languages—belongs in the group of high-level interpreted languages (Figure 1.11).
1.1.5 Object-oriented programming
In object-oriented programming, the interaction with the computer takes places through objects. Each object belongs to a class: an abstract structure with certain properties. Objects are in fact instances of a class.
The class comprises a template which sets the properties and methods each object of that class should have, while an object contains specific values for that particular instance (Figure 1.12).
- All cars we see in the parking lot are instances of the “car” class
- The “car” class has certain properties (manufacturer, color, year) and methods (start, drive, stop)
- Each “car” object has specific values for the properties (Suzuki, brown, 2011)
In R, as we will see later on, everything we work with are objects. For example, a raster—such as
rainfall.tif which we mentioned earlier (Section 126.96.36.199)—that we import into R is actually translated to an object of a class named
stars. The object has numerous properties, such as the number of rows an columns, the resolution, the Coordinate Reference System (CRS), and so on.
Once imported, an object named
r, belonging to the class named
stars is used to represent rasters in R, exists in the R environment (more specifically in the RAM, see Section 1.1.3). For example, printing to object displays some of its properties and their specific values, such as a resolution (
delta) of 1000 meters:
r ## stars object with 2 dimensions and 1 attribute ## attribute(s): ## rainfall.tif ## Min. :200.0 ## 1st Qu.:373.3 ## Median :500.7 ## Mean :483.8 ## 3rd Qu.:585.6 ## Max. :908.5 ## NA's :20780 ## dimension(s): ## from to offset delta refsys point values x/y ## x 1 153 616965 1000 WGS 84 / UTM zone 36N FALSE NULL [x] ## y 1 240 3691819 -1000 WGS 84 / UTM zone 36N FALSE NULL [y]
One of the implications of object-oriented programming is inheritance. Inheritance makes it possible for one class to “extend” another class, by adding new properties and/or new methods. Using our car example (Figure 1.12):
- A “taxi” is an extension of the “car” class, inheriting all of its properties and methods
- In addition to the inherited properties, a “taxi” has new properties (taxi company name) and new methods (switching the taximeter on and off)
In R, the idea of inheritance is realized in various ways. For example, every complex object (such as a raster) is actually a collection of smaller components (the properties). Looking at the structure of the raster object
r (using the
str function, see Section 188.8.131.52) reveals that it is, in fact, a collection of many small objects belonging to simpler classes, each holding a piece of information. For example, the resolution property (named
delta) is in fact a numeric vector (class
numeric, see Section 2.3) of length 1 (i.e., containing a single value,
str(r) ## List of 1 ## $ rainfall.tif: num [1:153, 1:240] NA NA NA NA NA NA NA NA NA NA ... ## - attr(*, "dimensions")=List of 2 ## ..$ x:List of 7 ## .. ..$ from : num 1 ## .. ..$ to : num 153 ## .. ..$ offset: num 616965 ## .. ..$ delta : num 1000 ## .. ..$ refsys:List of 2 ## .. .. ..$ input: chr "WGS 84 / UTM zone 36N" ## .. .. ..$ wkt : chr "PROJCRS[\"WGS 84 / UTM zone 36N\",\n BASEGEOGCRS[\"WGS 84\",\n DATUM[\"World Geodetic System 1984\",\"| __truncated__ ## .. .. ..- attr(*, "class")= chr "crs" ## .. ..$ point : logi FALSE ## .. ..$ values: NULL ## .. ..- attr(*, "class")= chr "dimension" ## ..$ y:List of 7 ## .. ..$ from : num 1 ## .. ..$ to : num 240 ## .. ..$ offset: num 3691819 ## .. ..$ delta : num -1000 ## .. ..$ refsys:List of 2 ## .. .. ..$ input: chr "WGS 84 / UTM zone 36N" ## .. .. ..$ wkt : chr "PROJCRS[\"WGS 84 / UTM zone 36N\",\n BASEGEOGCRS[\"WGS 84\",\n DATUM[\"World Geodetic System 1984\",\"| __truncated__ ## .. .. ..- attr(*, "class")= chr "crs" ## .. ..$ point : logi FALSE ## .. ..$ values: NULL ## .. ..- attr(*, "class")= chr "dimension" ## ..- attr(*, "raster")=List of 3 ## .. ..$ affine : num [1:2] 0 0 ## .. ..$ dimensions : chr [1:2] "x" "y" ## .. ..$ curvilinear: logi FALSE ## .. ..- attr(*, "class")= chr "stars_raster" ## ..- attr(*, "class")= chr "dimensions" ## - attr(*, "class")= chr "stars"
The benefit of inheritance is that the programmer does not need to write every class from scratch. Instead, new classes can be built on top of existing ones, while re-using their properties and methods.
1.2 Starting R
Now that we covered some central theoretical concepts related to programming, we are staring the practical part—writing R code to work with spatial data. In this chapter, we will become familiar with the R environment, its basic operators and syntax rules.
To use R, we first need to install it. R can be downloaded from the R-project website. The current version at the time of writing (October 2020) is R 4.0.3. Once R is installed, we can open the default interface (RGui) with Start → All Programs → R → R x64 4.0.3 (Figure 1.13).
We will be working with R through a more advanced interface than the default one, called the RStudio. It can be downloaded from the RStudio company website. The current version is RStudio 1.3.1093. Once both R and RStudio are installed, we can open RStudio with Start → All Programs → RStudio → RStudio (Figure 1.14).
In this Chapter, we will only work with the console, i.e., the command line. In the following lessons we will also work with other RStudio panels.
Locate the console in the RStudio interface, in the tab named “Console” (Figure 1.15).
1.3 Basic R expressions
1.3.1 Console input and output
The simplest way to interact with the R environment is typing an expression into the R console, pressing Enter to execute it. For example, let’s type the expression
After we press Enter, the expression
1+3+5+7 is sent to the processor. The returned value,
16, is then printed in the console. Note that the value
16 is not kept in in the RAM or Mass Storage, just printed on screen (Figure 1.16). We will talk about what the
 part means later on (Section 2.3.8), you can ignore it for now.
Note that, in the book, the outputs are marked with preceding two has symbols (
##), while the inputs start at the beginning of a line9. In RStudio, the input and output are displayed with different colors, without hash symbols (Figure 1.17).
We can type a number, the number itself is returned:
We can type text inside single
' or double
The last two expressions are examples of constant values,
character. These are the simplest type of expressions in R.
1.3.2 Arithmetic operators
Through interactive use of the command line, we can experiment with basic operators in R. For example, R includes the standard arithmetic operators (Table 1.1).
Here are some examples of expressions that use the arithmetic operators:
We can use the up ↑ and down ↓ keys to scroll through the executed expressions history. Try to execute several different expressions, then scroll up until you reach one of the previous expressions and re-execute it by pressing Enter. Scrolling through expression history is convenient for going back to previously exceuted code, without re-typing it, possibly making modifications before excecuting it once again.
Note that very large or very small numbers are formatted in exponential notation:
Infinity is treated as a special numeric value,
We can control operator precedence with brackets, just like in math:
It is recommended to use brackets for clarity, even where not strictly required.
1.3.3 Spaces and comments
The interpreter ignores everything to the right of the number symbol
# symbol is therefore used for code comments:
Why do you think the code outputs are marked by
##in the code sections (such as
##  25in the above code section)?
The interpreter ignores spaces, so the following expressions are treated exactly the same way:
We can type Enter in the middle of an expression and keep typing on the next line. The interpreter displays the
+ symbol, which means that the expression is incomplete (Figure 1.18):
We can exit from the “completion” state, or from an ongoing computation, any time, by pressing Esc.
Clearing the console can be done with Ctrl+L.
1.3.4 Conditional operators
Conditions are expressions that use conditional operators and have a yes/no result, i.e., the condition can be either true or false. The result of a condition is a logical value,
TRUEmeans the expression is true
FALSEmeans the expression is false
NAmeans it is unknown)
The conditional operators in R are listed in Table 1.2.
||Greater than or equal|
||Less than or equal|
For example, we can use conditional operators to compare numeric values:
==) and “not equal” (
!=) are opposites of each other, since a pair of values can be either equal or not:
The “and” (
&) and “or” (
|) operators are used to create more complex conditions. “And” (
TRUE when both sides are
TRUE when at least one of the sides is
The last conditional operator is “not” (
!), which reverses
Run the following expression and explain their result:
FALSE == FALSE
!(TRUE == TRUE)
!(!(1 == 1))
1.3.5 Special values
R has several special values, as listed in Table 1.3.
||Not a Number|
We already met
Inf, and have shown how it can be the result of particular arithmetic operations such as division by zero (Section 1.3.2):
NA specifies an unknown, or missing, value. Later on, we are going to encounter several situations where
NA values can arise. For example, empty cells in a table imported into R, such as from a CSV file (Section 4.4), are encoded in R as
NA values can participate in any arithmetic or logical operation. For example:
Why do you think the result of the above expression is
What do you think will be the result of the expression
NA == NA?
NaN is less relevant for the material of this book, but it is important to be familiar with it.
NaN values often result from “meaningless” arithmetic operations:
For most practical purposes,
NaN values behave exactly the same way as
Finally, the value of
NULL specifies an empty object:
NULL has some uses which we will discuss later on (Section 4.2.3).
In math, a function (Figure 1.19) is a relation that associates each element x of a set X, to a single element y of another set Y. For example, the function \(y=2x\) is a mathematical function that associates any number \(x\) with the number \(2x\).
The concept of functions in programming is similar. A function is a code piece that “knows” how to do a certain task. Executing the function is known as a function call. The function accepts zero or more objects as input (e.g.,
2) and returns a single object as output (e.g.,
4). In addition to the returned value, the function may perform other task(s), known as side effects (for example: writing information to a file, or displaying graphical output).
The number and type of inputs the function needs are determined in the function definition; these are known as the function parameters (e.g., a single number). The objects the function received in practice, as part of a particular function call, are known as arguments (e.g.,
A function is basically a set of pre-defined instructions. There are thousands of built-in functions in R. Later on we will learn to define our own functions (Section 3.3).
A function call is composed of the function name, followed by the arguments inside brackets
() and separated by commas
,. For example, the
sqrt function calculates the square root of its input. For example, the following expression calls the
sqrt function with the argument
sqrt function received a single argument
4 and returned its square root
As a side note, it is interesting to mention that everything we do in R in fact involves functions (Figure 1.20).
Even arithmetic operators are functions, just written in a special way. The arithmetic operators can be executed in the “ordinary” function syntax, too, as follows:
1.3.7 Error messages
Consider the following three different expressions:
In last two expressions we got error messages, because the expressions were illegal, i.e., not in agreement with the syntax rules of R. The first error occurred because we tried to run a mathematical operation
sqrt on a text value
"a". The second error occurred because we tried to use a non-existing object
a. Any text without quotes is treated as a name of an object, i.e., a label for an actual object stored in RAM. Since we don’t have an object named
a we got an error.
1.3.8 Pre-loaded objects
When starting R, a default set of objects is loaded into the RAM, such as
pi. For example, type
pi and see what happens:
1.3.9 Decimal places
Is the value of \(\pi\) stored in memory really equal to the value we see on screen (
3.141593)? Executing the following condition reveals that the answer is no:
If not, what is the difference?
The reason for the discrepancy is that, by default, R prints only the first 7 digits:
When working with R we should keep in mind that the printed value and object contents are not always identical, so that the printed output is more convenient for the user.
The number of digits to print can be changed with an expression such as
options(digits=22). Try running the latter expression, then print the value of
R is case-sensitive, it distinguishes between lower-case and upper-case letters. For example,
TRUE is a logical value, but
true are undefined:
R is an object-oriented language (Section 1.1.5), where each object belongs to a class. The
class functions accepts an object and returns the class name:
Explain the returned value of the following expressions.