RPR-Syntax basics
Basics of R syntax
(Simple commands and basic syntax, operators, variables, class, mode, and attributes)
Abstract:
This unit discusses simple R commands and basic syntax, operators, and R objects (variables).
|
Objectives:
|
Outcomes:
|
Deliverables:
Prerequisites:
This unit builds on material covered in the following prerequisite units:
Contents
Evaluation
Evaluation: NA
Contents
Unlike most other work in this course or workshop, the syntax uits are not condensed into an R project. You should actually type the code and execute it in the console. This is quite important at the beginning, to develop your recognition of pattern in the code, and the "muscle"-memory of typing it correctly. Take this seriously, this will pay off tremendously in the future.
Simple commands
The R command line evaluates expressions. Expressions can contain constants, variables, operators and functions of the various datatypes that R recognizes.
Operators
The common arithmetic operators are recognized in the usual way.
Task:
Open an RStudio session and try the following operators on numbers:
5 5 + 3 5 + 1 / 2 # Think first: is this 3 or 5.5 3 * 2 + 1 3 * (2 + 1) 2^3 # Exponentiation 8 ^ (1/3) # Third root via exponentiation 7 %% 2 # Modulo operation (remainder of integer division) 7 %/% 2 # Integer division # Logical operators return TRUE or FALSE # Unary: TRUE FALSE ! TRUE # read carefully: the "!" (meaning "not") is easily overlooked ! FALSE # Binary operators 1 == 2 1 != 2 1 < 2 1 > 2 1 > 1 1 >= 1 1 < 1 1 <= 1 # & (means AND) TRUE & TRUE TRUE & FALSE FALSE & FALSE # | (means OR) TRUE | TRUE TRUE | FALSE FALSE | FALSE # Predict what this will return !(FALSE | (! FALSE))
Task:
- Practice
- Given the expression shown below, the value of lastNum is 9:
numbers <- c(16, 20, 3, 5, 9) # the c() function collects elements into a vector numbers lastNum <- tail(numbers, 1) # explain what this does lastNum # Note: expressions in parentheses: # when we assign, e.g. ... numbers <- sample(1:20, 5) # ... we can get the value of the vector "numbers" with ... print(numbers) # ... or just ... numbers # But we can also put the entire expression in parentheses, and when it is # evaluated, which results in the assignment, the value is also printed. (numbers <- sample(1:20, 5)) # so: when you see parentheses around an entire expression, remember that all # the parentheses do is to perform some evaluation, and then print the # resulting object. I use this idiom lot for compactness in teaching code. # In general, you usually don't need this in scripts that you develop, but for # teaching I often need you to study the contents of a variable.
Write R expressions:
1) To check whether lastNum is less than 6 or greater than 10
2) To check whether lastNum is in the interval [10, 20). (By the rules of mathematical notation this means 10 is included but 20 is not).
3) To output TRUE if the following operation gives 2:
- take lastNum
- divide it by 7
- subtract the integer part and the first digit after the decimal point (hint: multiply by 10, then integer division by 1 gives you ... what)
- multiply by 100
- integer divide by 1
- take the third root
(Hints: use lots of parentheses and compare the final result to 2. To debug, select parts of the code and execute separately. If the console gets stuck because it is expecting a closing parenthesis, and all you see is the "+" sign, simply press <escape> to abort evaluation.)
Check your answers (but don't cheat) ...
1) lastNum < 6 | lastNum > 10 2) lastNum >= 10 & lastNum < 20 3) ((((9/7) - ((((9/7) * 10) %/% 1 )/10)) * 100) %/% 1 )^(1/3) == 2
Variables
In order to store the results of expressions and computations, you can freely assign them to variables[1]. Variables are created by R whenever you first use them (i.e. space in memory is allocated to the variable and a value is stored in that space.) Variable names distinguish between upper case and lower case letters. There are a small number of reserved names that you are not allowed to redefine, and R syntax contains very small number of predefined constants, such as pi. However these constants can be overwritten - be careful: R will allow you to define pi <- 3 but casually redefining the foundations of mathematics may lead to unintended consequences. Read more about variable names at:
?make.names ?reserved
To assign a value to a constant, use the assignment operator <-. This is the default way of assigning values in R. You could also use the = sign, but there are subtle differences. (See: ?"<-"). There is a variant of the assignment operator <<- which is sometimes used inside functions. It assigns to a global context. This is possible, but not preferred since it generates a side effect of a function. Don't do this. Just forget that <<- even exists.
a <- 5 a a + 3 b <- 8 b a + b a == b # not assignment: equality test a != b # not equal a < b # less than
Note that all of R's data types (as well as functions and other objects) can be assigned to variables.
There are very few syntactic restrictions on variable names (discussed eg. here) but this does not mean esoteric names are good. For the sake of your sanity, use names that express the meaning of the variable, and that are unique. Many R developers use loquatious dotted.variable.names, some people use the puttering pothole_style, my personal preference is to write noble names in camelCase. And while the single letters c f n s Q are syntactically valid variable names, they coincide with commands for the debugger browser and will execute debugger commands, rather than displaying variable values when you are debugging. Finally, try not to use variable names that are the same as parameter names in functions. You see this often in code, but such code can be hard to read because the semantics of the actual argument versus the parameter name becomes obscured. It's just common sense really: don't call different things by the same name.
# I don't like...
col <- c("#E5F2FF", "#F5F5F5")
hist(rnorm(2000), breaks = 25, col = col)
# I prefer instead something like...
stripes <- c("#E5F2FF", "#F5F5F5")
hist(rnorm(2000), breaks = 25, col = stripes)
Self-evaluation
Further reading, links and resources
Notes
- ↑ We call these "variables" because of what function they perform in our code, the actually are R "objects".
About ...
Author:
- Boris Steipe <boris.steipe@utoronto.ca>
Created:
- 2017-08-05
Modified:
- 2018-05-04
Version:
- 1.0.1
Version history:
- 1.0.1 Maintenance
- 1.0 Completed to first live version
- 0.1 Material collected from previous tutorial
This copyrighted material is licensed under a Creative Commons Attribution 4.0 International License. Follow the link to learn more.
