Intro to R

What is R?

An interactive programming language and environment focusing on statistics.

How does it work?

At its most basic level, you can open up R at the terminal and type commands.

2+2

[1] 4

sin(pi/2)

[1] 1

cos(pi/2)

[1] 6.123032e-17

(1:10) + 100

 [1] 101 102 103 104 105 106 107 108 109 110

Think of it like a calculator with a lot more features.

We’re going to learn some of those features today.

Why R?

Built around statistics and data analysis(especially omics and bioinformatics), and is one of the most popular languages for this purpose.

• There are other options that offer drag & drop statistics
  • SPSS
  • STATA
  • Prism
• But…
  • These platforms lack many statistical features
  • They are not scriptable
    • less reproducible
    • harder to verify results
    • manually repetitive
  • Require clean datasets
  • Cost money
• R isn’t just a point & click stats program. It’s an open source programming language built by a global community, and gives users access to a huge and constantly growing set of modern statistical tools.

Programming in the age of AI

You do not need to be an expert programmer to use R.

Large Language Models (LLMs) like ChatGPT and Claude can help generate, explain, and debug code quickly – with caveats.

Where AI helps

• Build simple apps quickly
• Explain tricky code
• Suggest syntax
• Debug errors

Where AI can fail

• Incorrect code
• Deleted or changed files
• Leaked confidential data
• Overconfidence

By the end of this week, you will know enough R to do simple tasks yourself and more complex tasks with LLM support.

Getting started with R:

There are three parts.

• R console
  • The place where the code is executed
• Text editor
  • The place to write your code
• Where to go for help
  • ‘?’ read the manuals
  • use an AI chatbot

R is a command line program, just like python. You can open it up from your terminal and start coding, but there are better ways to go about this.

Even though it’s possible to work directly in the R console, most people write their code in a separate file using a text editor that at least has syntax highlighting.

Up until very recently, most people learned R by following tutorials, and consulting the built in help documentation. This semester we’re trying a more modern approach utilizing AI.

Installing R

If you want to work locally, you’ll first need to install the R console on your computer.

• R website

Choose the appropriate option based on your operating system.

Using R

There are a number of ways to interact with R.

• You can open R and type directly into the console.

• You can work with a text editor of your choice and copy/paste lines into the R console.

• You can use an IDE (Integrated Development Environment ) that automatically links a text editor with the R console.

  • Rstudio is the most popular choice.

• You can use a cloud based IDE

  • Google Colab. This has everything that a local IDE does, but works on your browser using cloud resources instead of your local computer.

You have to choose one of these to use R, I suggest Rstudio

R packages

Programmers and Data Analysts write code to perform a task or solve a problem. If you encounter the same task again, you shouldn’t have to write everything again.

• What is the idea?

  • wrap everything needed to perform a task into a collection of files

  • make it easy for you or someone else to use that collection

  • provide documentation on how to use your code

What is an R package?

Packages are the main strength of R! It’s not the fastest language, or easiest to write in, but R has one of the largest ecosystems of statistical and data science libraries of any programming language, with tens of thousands of packages available through open source repositories. (~23k on CRAN, ~2500 on Bioconductor).

How to use them?

• install them once
• load them when you need them

install.packages(YOURPACKAGE)

library(YOURPACKAGE)

Files and Folders Basics

What are files?

A file is a saved item on your computer.

Examples of files include:

• A Word document
• A photo
• A spreadsheet
• A PDF
• An R script

In R, you may work with files such as:

• .R files
• .csv files
• .xlsx files
• .txt files

A file usually has a name and a file extension.

Example:

homework1.R

Here:

• homework1 is the file name
• .R is the file extension

The file extension tells the computer what kind of file it is.

---

What are folders?

A folder is a place where files are stored.

Folders help keep your work organized.

For example, you might have a folder called:

R_Projects

Inside that folder, you might have files like:

data.csv
homework1.R
results.txt

Folders can also contain other folders.

For example:

R_Projects
  Week_1
  Week_2
  Data
  Figures

This helps you keep related files together.

---

Why organization matters

When using R, it is important to know where your files are saved.

R often needs to find files on your computer.

For example, you might ask R to open a data file:

data.csv

But R needs to know where that file is located.

If R cannot find the file, you may get an error.

A common beginner problem is saving a file in one folder, but R is looking in a different folder.

Good organization makes R easier to use.

---

Saving files

When you save a file, you choose:

• The file name
• The folder where it will be stored
• The file type

For example, when saving an R script, you might save it as:

week1_notes.R

You should save it inside the folder for your class or project.

Example folder:

Documents/R_Class/Week_1

It is helpful to use simple file names.

Good file names:

week1_notes.R
data_cleaning.R
survey_data.csv

Avoid file names like:

My File!!!!.R
data final final version 2.csv
homework#1.R

Simple names without spaces or special characters are easier to use in R.

---

Moving files around

You can move files from one folder to another.

For example, you might move:

data.csv

from your Downloads folder into your R project folder.

This is often a good idea.

Files downloaded from the internet usually go to the Downloads folder first.

But if you are using the file for an R project, move it into the project folder.

Example:

Before:

Downloads/data.csv

After:

Documents/R_Class/Week_1/data.csv

This makes it easier for R to find the file.

---

What is the current working directory?

The current working directory is the folder where R is currently looking for files.

You can think of it as R’s current location on your computer.

If R is currently working inside this folder:

Documents/R_Class/Week_1

then R will look there first when you ask it to open a file.

For example:

read.csv("data.csv")

R will look for data.csv inside the current working directory.

If data.csv is not there, R may give an error.

---

Checking the current working directory

In R, you can check the current working directory with:

getwd()

This means “get working directory.”

It tells you the folder where R is currently looking.

Example output:

"/Users/name/Documents/R_Class/Week_1"

This means R is currently working inside the Week_1 folder.

---

Setting the working directory

You can change the working directory if needed.

One way is with:

setwd("/Users/name/Documents/R_Class/Week_1")

This tells R to use that folder as the current working directory.

However, beginners should be careful with setwd() because the folder path may be different on different computers.

Simple rule for beginners

Keep related files together.

For each class, homework, or project, create one folder.

Put your R scripts and data files in that folder.

Example:

Homework_1
  homework1.R
  data.csv

Then open the R script in Rstudio and make sure it’s using the proper working directory with getwd() and setwd().

---

Common beginner errors

Error: R cannot find my file.

Possible reasons:

• The file is saved in a different folder
• The file name is spelled differently
• The file extension is missing or wrong
• R is using a different working directory
• The file is still in Downloads

Things to check:

• Where is the file saved?
• What is the exact file name?
• What does getwd() say?
• Is the file inside the folder R is using?

---

Key takeaways

A file is a saved item on your computer.

A folder is a place where files are stored.

Files should be named clearly.

Related files should be kept together.

The current working directory is the folder where R is currently looking for files.

Use getwd() to check the current working directory.

The main goal is simple:

Know where your files are, and keep your project files together.

Rstudio Basics

This IDE has a lot of useful features but can be overwhelming at first.

We’re going to spend some time on a live demo to introduce some of the features.

• Key Points
  • Where is the text editor?
  • Where is the R console?
  • How do you send text from the editor to the console?
  • How do you make a new file?
    • so many options, which to choose?
  • What’s the Environment tab/panel in the top right corner?
  • What’s the panel in the bottom right corner?
    • Files
    • Plots
    • Packages
  • How do you set the current working directory?

Coding Basics

R is a complete programming language. Though it was designed specifically for statistical computing, it can do everything the other complete languages like c++ and python can do.

• Essential for this course
  • assignments (save stuff into variables)
  • variable access (use the data you’ve stored)
  • mathematical operations (calculator work)
  • reading/writing files (work with permanent storage)
  • visualization (plot your data)
  • calling functions (doing the work)
• Helpful for real world R use
  • writing functions (organize operations into a reusable form)
  • control (perform operations based on conditions)
  • loops (repeat operations)

We’ll now go through these things in detail.

Assignments

A way to capture the output of an operation so you can use it again.

A result can be stored into a variable with the <- (assignment) or = (equals) operator.

x <-  3848.2834 / 19283.2 + 3762.09271
print(x)

[1] 3762.292

y = x + 100 
print(y)

[1] 3862.292

myname <- "SuperlongFirstnameAndLastName"
print(myname)

[1] "SuperlongFirstnameAndLastName"

type

Variables have a class that represents the type of data they contain. You can find out the type of a variable by using the class() function.

class(x)

[1] "numeric"

class(myname)

[1] "character"

The common types you should be familiar with are

numeric

• a number
  • a patient’s blood pressure reading (mmHg)
  • a patients weight (in lbs)

integer

• a whole number
  • a patient’s age (in years)
  • how many children they have

character

• a string
  • name
  • description of their symptoms

factor

• a category with a predefined set of levels.
  • place of residence (urban,rural,suburb)
  • their smoking status (never, former, current)

logical

• a true/false
  • hypertension (yes/no)

vector

R allows you to store a collection of variables of the same type into something called a vector with the c (combine) command.

mynums <- c(1,2,3,4,5)
class(mynums)

[1] "numeric"

print(mynums)

[1] 1 2 3 4 5

mynames <- c("me", "you", "we", "them", "they")
class(mynames)

[1] "character"

print(mynames)

[1] "me"   "you"  "we"   "them" "they"

list

R allows you to store a collection of variables of different types into something called a list

mylist <- list(1,"me", 2, "we", 3)
class(mylist)

[1] "list"

print(mylist)

[[1]]
[1] 1

[[2]]
[1] "me"

[[3]]
[1] 2

[[4]]
[1] "we"

[[5]]
[1] 3

data.frame

R allows you to store a collection of lists or vectors into something called a data.frame.

Think of this like a spreadsheet were each observation gets own row and the variables are stored in the columns. You use the data.frame() function and pass in the vectors or lists that store your data and the column names you want them to appear as.

In the example below, the vector that we made earlier mynums is going to become the first column of the new data.frame and mynames the 2nd column. These 2 columns will be called nums and names in the data.frame. The whole thing is saved into a new variable called mydata.

mydata <- data.frame(nums=mynums, names=mynames)
print(mydata)

  nums names
1    1    me
2    2   you
3    3    we
4    4  them
5    5  they

matrix

A matrix is just like a data.frame except all elements are the same type. When constructing a matrix with the matrix() function, you can specify its dimensions with the ncol and/or nrow parameters.

myvec = c(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16)
print(myvec)

 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16

mymat = matrix(myvec, ncol=4)
print(mymat)

     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16

naming

You can also assign names to the rows and columns of your vectors, lists, and data.frames and matrices with the names() function. This can make things easier for you while you code and interpret your results.

print(mynums)

[1] 1 2 3 4 5

names(mynums) <- c("a", "b", "c", "d", "e")
print(mynums)

a b c d e 
1 2 3 4 5 

print(mydata)

  nums names
1    1    me
2    2   you
3    3    we
4    4  them
5    5  they

rownames(mydata) <- c("first", "second", "third", "fourth", "fifth")
print(mydata)

       nums names
first     1    me
second    2   you
third     3    we
fourth    4  them
fifth     5  they

rownames(mydata)

[1] "first"  "second" "third"  "fourth" "fifth" 

colnames(mydata)

[1] "nums"  "names"

Variable access

vectors & lists

Now that we know how to store our results, how do we access them?

The elements of a vector can be accessed with [] (single brackets)

mynums

a b c d e 
1 2 3 4 5 

mynums[3]

c 
3 

The elements of a list can be accessed with [[]] (double brackets)

mylist

[[1]]
[1] 1

[[2]]
[1] "me"

[[3]]
[1] 2

[[4]]
[1] "we"

[[5]]
[1] 3

mylist[[3]]

[1] 2

• gotcha: a list can be a collection of anything, including other lists. If you use single brackets [] on a list, it will return the specified element as a list. This is probably not what you want.

mylist[3]

[[1]]
[1] 2

class(mylist[3])

[1] "list"

mylist[[3]]

[1] 2

class(mylist[[3]])

[1] "numeric"

data.frames

You can access elements of data.frames by their rows and columns with [i,j] single brackets. The i before the , is the row, the j after the , is the column.

mydata

# the 4th row and 2nd column
mydata[4,2]

[1] "them"

You can also specify the location as a combination of numbers and row/col names

mydata["fourth",2]

[1] "them"

mydata[4,"names"]

[1] "them"

mydata["fourth", "names"]

[1] "them"

multiple elements

If you want to get an entire row, leave off the j in the [i,j] command

#get the 3rd row
mydata[3,]

If you want an entire column, leave off the i in the [i,j] command

#get the 2nd column
mydata[,2]

[1] "me"   "you"  "we"   "them" "they"

You can also get columns by using their specific column names with the $ or by using [[]] double brackets.

mydata$nums

[1] 1 2 3 4 5

mydata[["nums"]]

[1] 1 2 3 4 5

In addition to single elements, you can also specify ranges when accessing your data. The : command is shorthand notation for a range.
The command a:b returns a vector starting from a and ending on b. You can use this notation within the [] command to access contiguous ranges of a data.frame or vector.

1:5

[1] 1 2 3 4 5

5:9

[1] 5 6 7 8 9

#first 3 rows, first 2 columns
mydata[1:3, 1:2]

You can specify non contiguous ranges by using a vector within the [] command

#this returns the first 2 columns of the  first and third row
mydata[c(1,3), 1:2]

#this does the same thing
mydata[c("first", "third"), 1:2]

#what does this do?
mydata[c("third", "first"), 1:2]

If you want to remove rows or columns you can put a - (minus) before the accessor indices

#this will return the first two columns of the data.frame, but will skip the first row
mydata[-1, 1:2]

#this will return the first two columns of the data.frame, but will skip the 2nd row
mydata[-2, 1:2]

#this will return the first two columns of the data.frame, but will skip the first 2 rows
mydata[-(1:2), 1:2]

Mathematical Operations

Every language needs support for basic mathematical operations like +, -, *, etc. In R we have support for vector operations which apply the operator across every element of a vector.

Math on a single number

var1 = 5
(var1 * 2)/.3842

[1] 26.02811

Math on a vector of numbers

vec1 = c(1,2,3,4,5)
vec2 = (vec1 * 2)/.3842
vec2

[1]  5.205622 10.411244 15.616866 20.822488 26.028110

R also has support for operations like & logical AND, | logical OR, ! logical NOT and comparisions < less than, >= greater than or equals to, etc…

#which values of vec2 are less than 20?
ix = vec2 < 20
#the result of the comparisons is saved in a logical vector
ix

[1]  TRUE  TRUE  TRUE FALSE FALSE

Often times we will access certain rows of a data.frame based on the result of a logical operation

mydata 

#give me all the rows that are TRUE from the comparison above
mydata[ix,]

You can even call logical operators on the fly within the [i,j] accessors. Combining operators and accessors allows you to perform more interesting and useful commands than just using them alone.

mydata

#give me the `names` column of the rows that have a `num` greater than 2
mydata[mydata$num > 2,"names"]

[1] "we"   "them" "they"

Reading/Writing files

data.frames are the most common form of data you’ll be using in R. If your data comes from a spreadsheet with observations along the rows and the variables along the columns, then it is very straightforward mapping to an R data.frame.

If you want to save a data.frame into a comma separated values(.csv) file, it can be done with write.csv(). This is a function that has 2 main arguments

• file: The place you want to save it
• x: the data.frame you want to save

write.csv(file="mydata.csv", x=mydata)

Reading can be done from a .csv with read.csv(). The main argument to this function is:

• file: The place you want to read the file from

The read.csv()function returns the data.frame that you just read in. You need to remember to save it to a variable.

mydata2 = read.csv(file="mydata.csv")
print(mydata2)

       X nums names
1  first    1    me
2 second    2   you
3  third    3    we
4 fourth    4  them
5  fifth    5  they

Visualization

R is one of the most popular environments for making publication quality graphics today.

Most visualization procedures operate on a data.frame and have some way to tell it which columns you want to look at.

We’ll be dealing with this more in the next lectures, but here is an example of how to call the pairs() function, which shows a scatterplot of every combination of the columns in a data.frame.

pairs(iris[, 1:4], col = iris$Species, pch=19)

Functions

Think of these as a reusable sets of instructions. You give a function it a set of inputs, it applies a procedure, then gives you an output.

It’s a way of organizing your code, so you don’t have to keep copy/pasting the same lines of code and making slight variations in text.

Most of the work you do in R will be done through using functions already implemented in base R or by package developers and loaded through a library() call.

Functions are called by name, with arguments passed between a set of () parentheses. The interesting thing about R is that you can specify the arguments by name or by order, and the environment can figure out which is which.

• It’s usually best to pass arguments explicitly for clarity.

foo <- function(a, b, c){
  (a + b)/c
}

foo(3,6,1)

[1] 9

foo(a=3,b=6,c=1)

[1] 9

foo(b=6,c=1, 3)

[1] 9

foo(b=3,c=6, 1)

[1] 0.6666667

Control

If statement

Programming often involves the execution of code dependent on the result of an upstream process.

R has control operations that allows us to do this.

The most straightforward to use are the if/else statements.

result <- 7
if (result < 3){
    print("you win")
}else{
    print("you lose")
}

[1] "you lose"

ifelse() function

You can use the ifelse() function return a result that is conditional on the elements of a logical vector.

• The function takes 3 parameters:
  • test: a logical vector
  • yes: the value to return for true elements of test
  • no: return values for false

vals = c(123,453,233,54,1223,12)
ifelse(vals < 100, "small", "large")

[1] "large" "large" "large" "small" "large" "small"

Loops

for

We’ve already seen that we can wrap up a series of operations into a function.
What if we wanted to apply this function to a 100 columns in a dataset? Would we have to make 100 function calls?

R let’s us run commands over a set of inputs or range using a structure known as a for loop.

for (i in 1:100){
    if (i %% 2==0){
        print("even")
    } else{
        print("odd")
    }
    
}

[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"

apply

Another common way of applying a function over the rows or columns of a data.frame is with the apply function.

• apply is a function that has 3 parameters arguments
  • X: the data.frame you want to work with
  • MARGIN: either 1 or 2.
    • 1 means you want to apply over all the rows.
      
    • 2 means to apply over all columns
  • FUN: the function you want to apply

sum is a built-in function that adds up all the elements of a vector. Below we’re computing the sum over all the rows and all the columns using apply.

mymat

     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16

#apply over all the rows
apply(mymat, 1, sum)

[1] 28 32 36 40

#apply over all the columns
apply(mymat, 2, sum)

[1] 10 26 42 58

sapply

a function can be applied to each element of a vector with the sapply function.

• sapply has 2 arguments
  • X: the vector
  • FUN: the function you want to apply

#here we're making a function that returns the negative value of its input.
sillyfunc1 <- function(val){
    -val
}

mydata$nums

[1] 1 2 3 4 5

sapply(mydata$nums, sillyfunc1)

[1] -1 -2 -3 -4 -5

anonymous functions

In any of the apply-style loops you can also define a function on the fly with the anonymous function construct

sapply(mydata$nums, function(val){
    -val
})

[1] -1 -2 -3 -4 -5

by

You can apply a function across a splitting variable with the by function

• by has 3 arguments
  • data: the values you want to run the function over
  • INDICES: the splitting variable
  • FUN: the function you want to apply

mydata

by(mydata$nums, mydata$nums < 3, sum)

mydata$nums < 3: FALSE
[1] 12
------------------------------------------------------------------------------------ 
mydata$nums < 3: TRUE
[1] 3

Tying it all together with an example:

A statistics instructor wants to know whether students who used chatGPT scored differently on a quiz than students who studied using regular notes.

• The dataset r_ttest_50_observations.csv contains quiz scores from 50 students:
  • id: a unique identifier for each student
  • group: whether the student used chatgpt or notes
    • control: regular notes
    • treatment: chatgpt
  • value: the student’s quiz score

The research question is:

Is there a statistically significant difference in average quiz scores between the two groups?

Summary

R is great for data analysis.

• pros:
  • more statistics: a proper test is almost always available through packages
  • more features: especially for visualization
  • scriptable: automate repetitive tasks ensure analysis is reproduceable
• cons:
  • Not as easy as the drag&drop apps like Prism

How do we deal with the cons?

• Learn the basics of the language
• Practice with the homeworks
• Use AI to get help

What do you need to learn R?

Once you have the right environment setup, learning the language (and statistics) comes smoothly.

• Locally
  • The R console (install it)
  • A place to write code (Rstudio)
  • A place to get help with code (chatgpt)
• Cloud based
  • Google Colab does this all in one place.

It’s hard to figure everything out on your own without direction or help. That’s what this first week is for.

Today’s Cheat Sheet

Inspecting objects

Function	Purpose	Example
print(x)	Displays an object in the R console.	print(mydata)
class(x)	Shows the type or class of an object.	class(mynums)

Creating and organizing data

Function	Purpose	Example
c(...)	Combines values into a vector.	c(1, 2, 3)
list(...)	Creates a list that can contain different types of objects.	list(1, "me", 2)
data.frame(...)	Creates a table-like data frame.	data.frame(nums = mynums, names = mynames)
matrix(...)	Creates a matrix whose elements are all the same type.	matrix(myvec, ncol = 4)
names(x)	Gets or assigns names to the elements of an object.	names(mynums) <- c("a", "b", "c")
rownames(x)	Gets or assigns row names.	rownames(mydata)
colnames(x)	Gets or assigns column names.	colnames(mydata)

Packages

Function	Purpose	Example
install.packages()	Downloads and installs an R package. This usually only needs to be done once.	install.packages("ggplot2")
library()	Loads an installed package for the current R session.	library(ggplot2)

Files and folders

Function	Purpose	Example
getwd()	Displays R’s current working directory.	getwd()
setwd()	Changes R’s current working directory.	setwd("Documents/R_Class")
read.csv()	Reads a CSV file and returns a data frame.	read.csv("mydata.csv")
write.csv()	Saves a data frame as a CSV file.	write.csv(mydata, "mydata.csv")

Writing your own functions

Function or syntax	Purpose	Example
function(...)	Defines a reusable set of instructions.	function(x) { x + 1 }

Conditional operations

Function or structure	Purpose	Example
if / else	Runs different code depending on whether a condition is true or false.	if (x > 0) print("positive")
ifelse()	Returns different values for the TRUE and FALSE elements of a logical vector.	ifelse(vals < 100, "small", "large")

Repeating operations

Function or structure	Purpose	Example
for	Repeats code for each value in a sequence or collection.	for (i in 1:10) print(i)
apply()	Applies a function to each row or column of a matrix or data frame.	apply(mymat, 1, sum)
sapply()	Applies a function to each element and tries to simplify the result into a vector or matrix.	sapply(mynums, sqrt)
by()	Applies a function to groups defined by another variable.	by(mydata$nums, mydata$group, mean)
sum()	Adds together the values in a vector.	sum(mynums)

Important indexing syntax

These are operators rather than functions, but they are commonly used throughout R code.

Syntax	Purpose	Example
[i]	Selects one or more elements.	mynums[3]
[[i]]	Extracts a single element, commonly from a list.	mylist[[3]]
[i, j]	Selects rows and columns from a data frame or matrix.	mydata[4, 2]
$	Selects a data-frame column by name.	mydata$nums
:	Creates a consecutive sequence of numbers.	1:10
<-	Assigns a value to a variable.	x <- 5

Common logical operators

Operator	Meaning	Example
<	Less than	x < 10
>	Greater than	x > 10
<=	Less than or equal to	x <= 10
>=	Greater than or equal to	x >= 10
==	Equal to	x == 10
!=	Not equal to	x != 10
&	Logical AND	(x > 0) & (x < 10)
|	Logical OR	(x < 0) | (x > 10)
!	Logical NOT	!is.na(x)