class: center, middle, inverse, title-slide .title[ # Variables, Data types & Operators ] .subtitle[ ## Elements of the R language ] .author[ ### Marcin Kierczak & Nima Rafati ] --- exclude: true count: false <link href="https://fonts.googleapis.com/css?family=Roboto|Source+Sans+Pro:300,400,600|Ubuntu+Mono&amp;subset=latin-ext" rel="stylesheet"> <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.3.1/css/all.css" integrity="sha384-mzrmE5qonljUremFsqc01SB46JvROS7bZs3IO2EmfFsd15uHvIt+Y8vEf7N7fWAU" crossorigin="anonymous"> <!-- ------------ Only edit title, subtitle & author above this ------------ --> --- name: intro # Introduction In this lecture we will cover the basic elements of R language: - **variables and their types** - **operators** - vectors - numbers as vectors - strings as vectors - matrices - lists - data frames - objects - repeating actions: iteration and recursion - decision taking: control structures - functions in general - variable scope - core functions --- name: variables # Variables Imagine that you want to manipulate some numbers in your project simple operations can be done `2 + 2` but what if you want to do more complex operations or use the same number multiple times? ``` r 2 + 2 2 + 2 + 5 2 + 2 + 5 +10 .... ``` -- To use the same number multiple times you can use a **variable** to store the number and use the variable name instead of the number itself. We assign given value to a variable using `<-` operator (aka *assignment operator*). ``` r a <- 2 + 2 b <- 5 c <- 5 + 10 sum_a_b <- a + b sum_all <- a + b + c ``` -- # Is `<-` equivalent to `=`? Which one shall I use? - `val <- 3`, `val = 3` and `3 -> val` are three equivalent ways of assigning in R, But, it's best to use only `<-` to avoid possible confusion. The equal sign `=` should be used when setting function arguments ie; `f(a = 3)`. --- # Variables cted. We are not constrained to numbers... ``` r text1 <- 'a' text2 <- 'qwerty' text1 text2 ``` ``` ## [1] "a" ## [1] "qwerty" ``` --- name: variables_naming # Variables &mdash; naming conventions - How to write variable names? - What is legal/valid? - What is a good style? -- A syntactically valid name consists of letters, numbers and the dot or underline characters and starts with a letter or the dot not followed by a number. -- Names such as ".2way" are not valid, and neither are the so-called *reserved words*. --- name: variables_naming_reserved # Reserved words - `if, else, repeat, while, function, for, in, next, break, TRUE, FALSE, NULL, Inf, NaN, NA, NA_integer_, NA_real_, NA_complex_, NA_character_` - and you also **cannot** use: `c, q, t, C, D, I` and **SHOULD NOT** `T, F` | Symbol | Function | Typical Use | | ------ | -------------------------- | ---------------------------------- | | `c` | Combine values | Create vectors | | `q` | Quit session | Exit R safely | | `t` | Transpose | Matrix operations | | `C` | Complex number constructor | Create complex values | | `D` | Derivative | Symbolic differentiation | | `I` | Inhibit interpretation | Keep operators literal in formulas | | `T` | Logical TRUE | Logical operations | | `F` | Logical FALSE | Logical operations | --- name: variables_good_style # Variables &mdash; good style - So, how to name variables? - make them informative, e.g. `genotypes` instead of `fsjht45jkhsdf4`, -- - use consistent notation across your code &ndash; the same *naming convention*, -- - camelNotation vs. dot.notation vs. dash_notation, -- - do not `give_them_too_long_names`, -- - in the dot notation avoid `my.variable.2`, use `my.variable2` instead, -- - there are certain customary names: - `tmp` - for temporary variables; - `cnt` for counters; - `i,j,k` within loops, - `pwd` - for password... -- **Why to care at all, I just want to analyze my data?** - For your future self, coming back to the code after a while. - For your collaborators, who will read your code. - For the community, if you share your code publicly. --- name: data_types_1 # Variables have types A *numeric* stores numbers of different *types*: ``` r x <- 41.99 # assign 41.99 to x typeof(x) ``` ``` ## [1] "double" ``` --- name: class_type_mode # Classes, types, and modes - `class` what type of object is it for R; **objects can be data (variables), functions, and models**. - `typeof()` what R thinks it is, ``` r x <- 1:3 x class(x) typeof(x) y <- 'hello' y class(y) typeof(y) lm <- lm(Sepal.Length ~ Sepal.Width, data=iris) # lm is a function for linear models. class(lm) ``` ``` ## [1] 1 2 3 ## [1] "integer" ## [1] "integer" ## [1] "hello" ## [1] "character" ## [1] "character" ## [1] "lm" ``` --- name: type_casting # Type casting (Converting data types) By default, any *numeric* is stored as *double* ! ``` r y <- 12 # now assign an integer value to y class(y) # still numeric typeof(y) # an integer, but still a double! ``` ``` ## [1] "numeric" ## [1] "double" ``` But we can explicitly **cast it** to integer: ``` r x <- as.integer(x) # type conversion, casting typeof(x) class(x) is.integer(x) ``` ``` ## [1] "integer" ## [1] "integer" ## [1] TRUE ``` > We need **casting** because sometimes a function requires data of certain type! --- name: casting2 # More on type casting Be careful when casting! ``` r pi <- 3.1415926536 # assign approximation of pi to pi pi pi <- as.integer(pi) # not-so-careful casting pi pi <- as.double(pi) # trying to rescue the situation pi ``` ``` ## [1] 3.141593 ## [1] 3 ## [1] 3 ``` -- Casting is not rounding! ``` r as.integer(3.14) as.integer(3.51) ``` ``` ## [1] 3 ## [1] 3 ``` --- name: ceiling_floor # Ceiling, floor and a round corner ``` r floor(3.51) # floor of 3.51 ceiling(3.51) # ceiling of 3.51 round(3.51, digits=1) # round to one decimal ``` ``` ## [1] 3 ## [1] 4 ## [1] 3.5 ``` --- name: coercion # What happens if we cast a string to a number ``` r as.numeric('4.5678') as.double('4.5678') as.numeric('Nima is a cool teacher :) !') ``` ``` ## [1] 4.5678 ## [1] 4.5678 ## [1] NA ``` --- name: some_special_values # Special values ``` r -1/0 # Minus infinity 1/0 # Infinity ``` ``` ## [1] -Inf ## [1] Inf ``` and also: ``` r 112345^67890 # Also infinity for R; "^" means "to the power of"; 2^2 = 4 1/2e78996543 # Zero for R Inf - Inf # Not a Number ``` ``` ## [1] Inf ## [1] 0 ## [1] NaN ``` --- name: logical_type # Logical type ``` r a <- 7 > 2 b <- 2 >= 7 a b class(a) typeof(a) ``` ``` ## [1] TRUE ## [1] FALSE ## [1] "logical" ## [1] "logical" ``` --- name: logical_cted # Logical type cted. ``` r x <- TRUE x x <- T # also valid x is.logical(x) typeof(x) ``` ``` ## [1] TRUE ## [1] TRUE ## [1] TRUE ## [1] "logical" ``` - Observe that in R the logical type is also a numeric! ``` r x <- TRUE y <- FALSE x + y 2 * x x * y ``` ``` ## [1] 1 ## [1] 2 ## [1] 0 ``` --- name: logical_joke # A trap set up for you Never ever use variable names as T or F. Why? ``` r F <- T T F ``` ``` ## [1] TRUE ## [1] TRUE ``` Maybe applicable in politics, but not really in science... --- name: character_type # Character type It is easy to work with characters and strings: ``` r character <- 'c' text <- 'This is my first sentence in R.' text character class(character) typeof(text) # also of 'character' type ``` ``` ## [1] "This is my first sentence in R." ## [1] "c" ## [1] "character" ## [1] "character" ``` --- name: character_type_2 # Character type ``` r number <- 3.14 number.text <- as.character(number) # cast to char number.text class(number.text) as.numeric(number.text) # and the other way round ``` -- ``` ## [1] "3.14" ## [1] "character" ## [1] 3.14 ``` --- name: basic_string_ops # Basic string operations ``` r text1 <- "John had a yellow " text2 <- "submarine" result <- paste(text1, text2, ".", sep='') result sub("submarine", "cab", result) substr(result, start=1, stop=5) ``` ``` ## [1] "John had a yellow submarine." ## [1] "John had a yellow cab." ## [1] "John " ``` --- name: basic_printing # Basic printing ``` r txt <- "blue" (txt <- 'red') val <- 345.78 sprintf("The weight of a %s ball is %g g", txt, val) ``` ``` ## [1] "red" ## [1] "The weight of a red ball is 345.78 g" ``` --- # What did we learn? <div style="font-size:70%"> | Concept | Key Idea | Example / Tip | | ------------------ | ------------------------------------------------ | ------------------------ | | **Variables** | Store data using names | `x <- 5` | | **Assignment** | Prefer `<-` for clarity | `a <- 2 + 2` | | **Naming rules** | Must start with letter/dot; avoid reserved words | ❌ `if`, `c`, `T`, `F` | | **Good style** | Use clear, consistent names | `gene_count`, `sampleID` | | **Data types** | Numeric, character, logical, etc. | `typeof(x)` / `class(x)` | | **Type casting** | Change one type to another | `as.integer(3.14)` | | **Special values** | `Inf`, `-Inf`, `NaN`, `NA` | `1/0 → Inf` | | **Logical values** | TRUE/FALSE behave like 1/0 | `TRUE + FALSE → 1` | | **Strings** | Text manipulation | `paste("R", "rocks!")` | | **Operators** | `+ − * / ^` (power) | `2^3 → 8` | | **Objects** | Everything in R is an object | data, functions, models | -- <div style="font-size:100%"> **Remember** - R treats everything as an **object**. - Use `class()` to see what kind of object it is. - Use `typeof()` to see how it’s stored internally. - Code readability **>>** clever shortcuts. - Naming and clarity make collaboration easier. <!-- --------------------- Do not edit this and below --------------------- --> --- name: end_slide class: end-slide, middle count: false # See you at the next lecture! .end-text[ <p class="smaller"> <span class="small" style="line-height: 1.2;">Graphics from </span><img src="./assets/freepik.jpg" style="max-height:20px; vertical-align:middle;"><br> Created: 23-Oct-2025 • <a href="https://www.scilifelab.se/">SciLifeLab</a> • <a href="https://nbis.se/">NBIS</a> </p> ]