Course Team

Instrutor

• Dr. Colin Rundel
  • colin.rundel@duke.edu / cr173@duke.edu / rundel@gmail.com
  • Office hours: 204 Old Chem or Zoom - Time TBD or by appointment

TAs

• Lynn Kremers
• Grady Purcell

Course website(s)

• GitHub pages - https://sta323-sp26.github.io
  • HTML, PDF, and qmds of Slides
  • Readings and other notes
• Canvas - https://canvas.duke.edu/courses/73157
  • Announcements
  • Gradebook

Labs

• Attendance is expected - must attend lab you are enrolled in

• Opportunity to work on course assignments with TA support

• Labs will begin next week - Monday (1/12)

Assessment

This course is graded 100% on your coursework (there are no exams).

We will be assessing you based on the following:

Teams

• Roughly biweekly homework assignments

• Open ended, ~5 - 15 hours of work

• Peer evaluation after completion

• Expectations and roles:

  • Everyone is expected to contribute equal effort
  • Everyone is expected to understand all code turned in
  • Individual contribution evaluated by multiple metrics (peer evaluation, commits, etc.)

Collaboration policy

• Only work that is clearly assigned as team work should be completed collaboratively (Homeworks + Project).

• Individual assignments (Midterms) must be completed individually, you may not directly share or discuss answers / code with anyone other than the myself and the TAs.

• On Homeworks you should not directly share answers / code with other teams, however you are welcome to discuss the problems in general and ask for advice.

Sharing / reusing code / AI policy

• We are aware that a huge volume of code is available on the web, and many tasks may have solutions posted.

• Unless explicitly stated otherwise, this course’s policy is that you may make use of any online resources (e.g. Google, StackOverflow, etc.) but you must explicitly cite where you obtained any code you directly use or use as inspiration in your solution(s).

• Any recycled/copied code that is not explicitly cited will be treated as plagiarism, regardless of source.

• The same applies to the use of LLM like ChatGPT, Claude, Gemini, or GitHub Copilot - you are welcome to make use of these tools as the basis for your solutions but you must cite the tool when using it for significant code generation.

Brief thoughts on AI tools

• AI tools are not a replacement for understanding the material, but they can be a tool to help you understand the material.

• Reaading code and writing code are skills that take time and practice to develop - both are essential.

• Nature of the tools is changing rapidly - Autocomplete vs ChatBots vs Agentic

  • Google Gemini and GitHub Copilot have “free” student options

Academic integrity

Accessing RStudio Workbench

To reduce friction, the preferred method is to use the department’s RStudio server(s).

To access RStudio/Posit Workbench:

1. Navigate to https://rstudio.stat.duke.edu
2. Log-in with your Duke NetID and password.

DSS RStudio alternatives

If you cannot access RStudio via the DSS servers:

• Make sure you are on authenticated Duke network (e.g. DukeBlue or VPN)

• Make sure you are not using a custom DNS server

  • e.g. 1.1.1.1 or 8.8.8.8

• As emergency back you can use a Docker container from Duke OIT

  1. Go to https://cmgr.oit.duke.edu/ and login
  2. Select Reserve a Container and find a container for any Sta course
  3. Click the link under my reservations to create your environment

Local R + RStudio

If working locally you should make sure that your environment meets the following requirements:

• latest R (4.5.2)

• latest RStudio (2026.01.0)

• working git installation

• ability to create ssh keys (for GitHub authentication)

• All R packages updated to their latest version from CRAN

GitHub

• We will be using a GitHub organization for this course github.com/sta323-sp26

• All assignments will be distributed and collected via GitHub

• All of your work and your membership (enrollment) in the organization is private

• We will be distributing a survey this weekend to collection your GitHub account names

  • Before lab you will be invited to the course organization.

• All course related repositories will be created for you

Before Monday

• Create a GitHub account if you don’t have one

• Complete the course survey

• Make sure you can login in to the Department’s RStudio server https://rstudio.stat.duke.edu

• Setup ssh key authentication with GitHub, see https://github.com/DukeStatSci/github_auth_guide

Vectors

The fundamental building block of data in R are vectors (collections of related values, objects, etc).

Atomic Vectors

R has six atomic vector types.

We can check the type of any object in R using the typeof() function. mode() is a higher level abstraction used to group similar types together.

logical - boolean values (TRUE and FALSE)

typeof(TRUE)

[1] "logical"

typeof(FALSE)

[1] "logical"

mode(TRUE)

[1] "logical"

mode(FALSE)

[1] "logical"

T

[1] TRUE

T = "FALSE"
T

[1] "FALSE"

character - text strings

Either single or double quotes are fine, the opening and closing quote must match.

typeof("hello")

[1] "character"

typeof('world')

[1] "character"

mode("hello")

[1] "character"

mode('world')

[1] "character"

"abc'123"

[1] "abc'123"

'abc"123'

[1] "abc\"123"

"abc\"123"

[1] "abc\"123"

'abc\'123'

[1] "abc'123"

Numeric types

double - floating point values (these are the default numerical type)

typeof(1.33)

[1] "double"

typeof(7)

[1] "double"

mode(1.33)

[1] "numeric"

mode(7)

[1] "numeric"

typeof( 7L )

[1] "integer"

typeof( 1:3 )

[1] "integer"

mode( 7L )

[1] "numeric"

mode( 1:3 )

[1] "numeric"

Combining / Concatenation

Atomic vectors can be constructed using the combine c() function.

c(1, 2, 3)

[1] 1 2 3

c("Hello", "World!")

[1] "Hello"  "World!"

c(1, 1:10)

 [1]  1  1  2  3  4  5  6  7  8  9 10

c(1,c(2, c(3)))

[1] 1 2 3

Type predicates

• is.logical(x) - returns TRUE if x has type logical.
• is.character(x) - returns TRUE if x has type character.
• is.double(x) - returns TRUE if x has type double.
• is.integer(x) - returns TRUE if x has type integer.
• is.numeric(x) - returns TRUE if x has mode numeric.

is.integer(1)

[1] FALSE

is.integer(1L)

[1] TRUE

is.integer(3:7)

[1] TRUE

is.double(1)

[1] TRUE

is.double(1L)

[1] FALSE

is.double(3:8)

[1] FALSE

is.numeric(1)

[1] TRUE

is.numeric(1L)

[1] TRUE

is.numeric(3:7)

[1] TRUE

Other useful predicates

• is.atomic(x) - returns TRUE if x is an atomic vector.
• is.list(x) - returns TRUE if x is a list (generic vector).
• is.vector(x) - returns TRUE if x is either an atomic or generic vector.

is.atomic(c(1,2,3))

[1] TRUE

is.list(c(1,2,3))

[1] FALSE

is.vector(c(1,2,3))

[1] TRUE

is.atomic(list(1,2,3))

[1] FALSE

is.list(list(1,2,3))

[1] TRUE

is.vector(list(1,2,3))

[1] TRUE

Type Coercion

R is a dynamically typed language – it will automatically convert between most types without raising warnings or errors. Keep in mind that atomic vectors must always contain values of the same type.

c(1, "Hello")

[1] "1"     "Hello"

c(FALSE, 3L)

[1] 0 3

c(1.2, 3L)

[1] 1.2 3.0

c(FALSE, "Hello")

[1] "FALSE" "Hello"

Operator coercion

Builtin operators and functions (e.g. +, &, log(), etc.) will generally attempt to coerce values to an appropriate type for the given operation (numeric for math, logical for logical, etc.)

3.1+1L

[1] 4.1

5 + FALSE

[1] 5

log(1)

[1] 0

log(TRUE)

[1] 0

TRUE & FALSE

[1] FALSE

TRUE & 7

[1] TRUE

TRUE | FALSE

[1] TRUE

FALSE | !5

[1] FALSE

Explicit coercion

Most of the is functions we just saw have an as variant which can be used for explicit coercion.

as.logical(5.2)

[1] TRUE

as.character(TRUE)

[1] "TRUE"

as.integer(pi)

[1] 3

as.numeric(FALSE)

[1] 0

as.double("7.2")

[1] 7.2

as.double("one")

Warning: NAs introduced by coercion

[1] NA

Missing Values

R uses NA to represent missing values in its data structures.

What may not be obvious is that there are different NAs for the different atomic types.

NA

[1] NA

NA+1

[1] NA

NA+1L

[1] NA

c(NA,"")

[1] NA ""

typeof(NA)

[1] "logical"

typeof(NA+1)

[1] "double"

typeof(NA+1L)

[1] "integer"

typeof(c(NA,""))

[1] "character"

typeof(NA_character_)

[1] "character"

typeof(NA_real_)

[1] "double"

typeof(NA_integer_)

[1] "integer"

typeof(NA_complex_)

[1] "complex"

NA stickiness

As NAs represent missing values (most) calculations using them return a missing value.

1 + NA

[1] NA

1 / NA

[1] NA

NA * 5

[1] NA

sqrt(NA)

[1] NA

3^NA

[1] NA

sum(c(1, 2, 3, NA))

[1] NA

sum(c(1, 2, 3, NA), na.rm = TRUE)

[1] 6

mean(c(1, 2, 3, NA), na.rm = TRUE)

[1] 2

NAs are not always sticky

A useful mental model for NAs is to consider them as a unknown value that could take any of the possible values for a given type.

TRUE & NA

[1] NA

FALSE & NA

[1] FALSE

TRUE | NA

[1] TRUE

FALSE | NA

[1] NA

Other Special values (double)

These are defined as part of the IEEE floating point standard (not unique to R)

• NaN - Not a number

• Inf - Positive infinity

• -Inf - Negative infinity

-1 / 0

[1] -Inf

0 / 0

[1] NaN

1/0 + 1/0

[1] Inf

Inf - Inf

[1] NaN

NaN / NA

[1] NA

NaN * NA

[1] NA

Testing for Inf and NaN

there are predicate functions for testing for these types of values

is.finite(Inf)

[1] FALSE

is.infinite(-Inf)

[1] TRUE

is.nan(Inf)

[1] FALSE

Inf > 1

[1] TRUE

is.finite(NaN)

[1] FALSE

is.infinite(NaN)

[1] FALSE

is.nan(NaN)

[1] TRUE

-Inf > 1

[1] FALSE

is.finite(NA)

[1] FALSE

is.infinite(NA)

[1] FALSE

is.nan(NA)

[1] FALSE

Coercion for infinity and NaN

First remember that Inf, -Inf, and NaN are doubles, however their coercion behavior is not the same as other doubles

as.integer(Inf)

Warning: NAs introduced by coercion to integer range

[1] NA

as.integer(NaN)

[1] NA

as.logical(Inf)

[1] TRUE

as.logical(-Inf)

[1] TRUE

as.logical(NaN)

[1] NA

as.character(Inf)

[1] "Inf"

as.character(-Inf)

[1] "-Inf"

as.character(NaN)

[1] "NaN"

Exercise 1

Part 1

What is the type of the following vectors? Explain why they have that type.

c(1, NA+1L, "C")
c(1L / 0, NA)
c(1:3, 5)
c(3L, NaN+1L)
c(NA, TRUE)

Part 2

Considering only the four (common) data types, what is R’s implicit type conversion hierarchy (from highest priority to lowest priority)?