In olobiolo/Rdlazer: Resources for Teaching R

knitr::opts_chunk$set(
  collapse = TRUE,
  comment = "#>"
)

RStudio Basics

• the Console is on the bottom left and that is where the magic happens
• the upper left is the Source, or script, from where we can execute consecutive lines of code
• the upper right shows the contents of the Global Environment, which can be useful
• help and plots will appear on the bottom right

\newline

• use Ctrl+1 to go to Source and Ctrl+2 to go to Console (and Ctrl+3 to go to the help tab)
• when in source, use Ctrl+Enter to execute the current line of code
• use Ctrl+Enter to execute a highlighted block of code: several lines or part of a line

\newline

• workspace and console history can be saved and loaded between sessions; I myself never do it

Console Basics

• execute a statement with Enter
• use Up and Down arrows to navigate console history
• use Ctrl+L to clear the console (does not affect history)
• autocomplete exists for object names, argument names and access paths
• it is trigerred by Tab
• call for help like this:

?Rdlazer
help(Rdlazer)
help("Rdlazer")

• each statement is executed separately
• by convention each statement is put in a single separate line
• each line may, but need not, end with a semicolon (;)
• a single line can hold multiple statements, provided they are separated by semicolons
• a single statement can span multiple lines; in some cases, this can improve intelligibility
• a block of code contained within braces will be executed in its entirety
• when the cursor is on or after a close* sign, the appropriate open* sign is highlighted
• this goes for parentheses ( ( ), brackets ( [ ) and braces ( { )

Comments

• the pound sign (#) is a comment sign
• everything right of a # in a line is considered a comment rather than code and will not executed
• comments are put in source rather than the console; you want the console to do things, after all
• commenting code is very helpful for other people to understand code
• other people include yourself some (surprisingly short) time in the future

Basic Programming From An R Perspective

• there are four basic types of data: logical, character, integer and double
• there are other types in R but that is deep lore and we don’t need it here
• integer and double are much the same for most purposes, so they are both treated as numeric
• integers are created explicitly by adding L to a digit: 1L
• missing values are called NA for not available
• NAs are not absent! they are there, they are just unknown
• a lack of anything is represented by NULL, a "nothing" object

character strings

• character strings are delineated by quote marks, double (") or single (')
• to place a quote mark within a string you must escape it by preceding it with \
• whitespace can be encoded in strings with special characters: \t for tab, \n for new line
• in these cases the backslash bestows special meaning rather than removes it as with quotes

Boolean logic
*named after British mathematician George Bool; it is said he died because he was set to FALSE*

• logical values can be TRUE or FALSE; these are reserved words
• T and F are aliases for TRUE and FALSE; these are not reserved
• logical values can be interpreted as integers with 1 for TRUE and 0 for FALSE
• logical operators are:
  • ==      test identity; is this the same as that?
  • !         negate; reverse a logical value
  • !=       test difference; is this different to that?
  • &       AND; are both items TRUE; analogous to multiplication
  • |         OR; is any of the two items TRUE; analogous to addition
• NAs cannot be compared to anything, so comparing an NA always yields an NA

simple maths

• most arithmetic operations are implemented as operators:
  • +, -, *, /, ^      add, subtract, multiply, divide, raise to power
  • %%, %/%      division remainder, modulus
• numeric values can be compared by operators:
  • ==, !=             test equality/inequality
  • >, <, >=, <=   greater than, less than, greater or equal, less or equal
  • operation precedence is as usual, including parentheses

variables

• a variable is a binding of a value to a name (a.k.a. symbol)
• a variable is created or declared by assigning a value to a name
• a name can consist of any letters (lower- and uppercase), digits, periods, dashes and underscores but must not begin with a digit or dash (-)
• variables with names beginning with a period (.) are hidden
• actually, names can contain illegal characters (even spaces!) but must be referred to with backticks
• this is a backtick: `
• a variable, as well as a binding, exists in an environment (more on environments later)
• variables can be created by <-, -> and = (name on left and value on right)
• it is good style to always use <-, with spaces around it for intelligibility
• <<- and ->> also assign variables but do not use them unless you have to (more on this later)
• when creating a variable, its type is determined automatically (unlike in, say, Java or C)
• a new value can be assigned to an existing symbol, overwriting the previous value

functions

• where a variable is a thing that is, a function is a thing that does
• a function is a block of code that can and will perform a sequence of operations
• some functions consist of R code but many are written in C for efficiency and cannot be read
• functions are stored in memory as a special type of object called closure
• a function will usually take input, possibly some existing variables/objects
• a variable that is used by a function is said to be passed to a function
• variables passed to a function remain unaffected
• a functions expects a certain type of input and it it encounters an object of a different type, it will attempt to convert it to as appropriate one; this is called coercion
• a function will usually produce output
• the output value is returned
• an instance of a function’s action is a function call
• a function’s behavior can be modified; this is done by setting arguments, a.k.a. parameters
• a function’s definition contains a list of arguments in a particular order
• a function is called by writing its name followed by parentheses containing arguments: foo(x, y)
• some arguments have default values (supplied in the definition) and can be omitted from a call
• there are three ways of matching a value to an argument in a call:
  • by name: arguments in a call are provided as name = value pairs
  • by partial name: the name need not be complete as long as it can be uniquely matched
  • by position: unnamed values are matched in the order they appear in the function definition

\newline

• some functions have a special argument, ...

• it is used in two situations:

  • to accept a variable number of arguments
  • to pass arguments to other functions (more on this later)

• some functions work as infix operators: the call is structured x op y rather than foo(x, y)

• examples of this are: %in% or + or <-

Use the foo function to play around with function calls.

flow control

several special constructs allow for controlling code behavior

1. perform actions conditionally with if and else:

• the if statement consists of a condition and an expression:

if (condition) {
  expression
}

• expression (the block of code within the braces) is only executed if condition is TRUE

\newline

• an if statement can be followed by an else statement, which contains an alternative expression:

if (condition) {
  expression1
} else {
  expression2
}

• the alternative expression will only be executed if the condition is FALSE

\newline

• if statements can be nested:

if (condition1) {
  if (condition2) {
    expression1
  } else {
    expression2
  } else {
    expression3
  }
}

• expression1 will be executed only if both conditions are TRUE
• condition2 is tested only if condition1 is TRUE

\newline

• else and if can be used to build a sequence of alternatives with multiple conditions:

if (condition1) {
  exrpession1
} else if (condition2) {
  exrpession2
} else if (condition3) {
  exrpession3
} else {
  exrpession4
}

• after one condition is found to be TRUE, the others are not tested
• only the first block of code for which the condition is TRUE will be executed
• WARNING: never brake a line before an else!

\newline

2. perform actions iteratively with loops:

• a loop will execute a set of expressions (the body) iteratively
• the next command will interrupt an iteration and move the loop on to the next one
• the break command will terminate the loop immediately

\newline

• a for loop:

for (iterator in sequence) {
  expression1
  expression2
  expression...
  }

\newline

• the iterator takes on the values of consecutive items in the sequence in each iterations

• the expressions in the body of the loop can make use of the iterator, e.g. pass it to functions

• a repeat loop:

repeat {
  expression1
  expression2
  expression...
}

• the body of the loop will be repeated over and over until a break is encountered

\newline

• a while loop:

while(condition) {
  expression1
  expression2
  expression...
}

• the condition is tested before every iteration and the loop runs as long as it is TRUE

A Look Ahead

The following material will be covered in detail in following lectures. This is just a sneak peak that will be necessary to solve the homework assignments.

1) vectors - the basic data structure in R is called a vector - it is a sequence of items of the same type; thus a vector also has a type - the number of items in a vector constitutes its length - vectors are most commonly created with the function c

# build a character vector
c('one', 'two', 'three', 'four')

2) sets - a vector can be thought of as a set of elements - you can test whether something is an element of a vector with function is.element or %in%

3) concatenating strings - character strings can be concatenated with the function paste

olobiolo/Rdlazer documentation built on Aug. 6, 2022, 11:37 a.m.