Operatory arytmetyczne

x <- 4
y <- 2

# dodawanie
x + y

## [1] 6

# odejmowanie
x - y

## [1] 2

# mnożenie
x * y

## [1] 8

# dzielenie 
x / y

## [1] 2

# modulus 
x %% y

## [1] 0

# power
x ^ y

## [1] 16

Operatory logiczne

# równe?
x == y

## [1] FALSE

# nie równe?
x != y

## [1] TRUE

# większe od?
x > y

## [1] TRUE

# mniejsze od?
x < y

## [1] FALSE

# większe lub równe od?
x >= y

## [1] TRUE

# mniejsze lub równe od?
x <= y

## [1] FALSE

Operator OR | i operator AND & są przydatne, gdy mamy do czynienia z twierdzeniami logicznymi.

(x > y) | (y < x)

## [1] TRUE

(x > y) & (y < x)

## [1] TRUE

c(F,F,F,T,F,F) | c(F,F,F,F,F,F)

## [1] FALSE FALSE FALSE  TRUE FALSE FALSE

Teraz istnieją również dwa warianty || i &&. Operatory te porównują elementy od lewej do prawej i zatrzymują się po pierwszym elemencie. Rozważmy ten sam przykład powyżej, zastępując | przez ||. Wynikiem jest jeden element, a nie wektor.

c(F,F,F,T,F,F) || c(F,F,F,F,F,F)

## Warning in c(F, F, F, T, F, F) || c(F, F, F, F, F, F): 'length(x) = 6 > 1' in
## coercion to 'logical(1)'

## Warning in c(F, F, F, T, F, F) || c(F, F, F, F, F, F): 'length(x) = 6 > 1' in
## coercion to 'logical(1)'

## [1] FALSE

Lepszą praktyką jest używanie any() i all() do oceny wektorów logicznych na pojedynczy logiczny.

# Czy któreś z nich jest TRUE?
any(c(F,F,F,T,F,F))

## [1] TRUE

# Czy wszystkie z nich są TRUE?
all(c(F,F,F,T,F,F))

## [1] FALSE

Znaki/łańcuchy mogą być przypisane do zmiennych w podobny sposób.

z <- "to"
z1 <- "tamto"
paste(z,z1)

## [1] "to tamto"

Funkcja paste() łączy ciągi znaków.

Nazwy zmiennych muszą być tak dobrane, aby nie kolidowały z istniejącymi zmiennymi/funkcjami. Na przykład należy unikać nazwy zmiennej c, ponieważ jest to istniejąca funkcja do konkatenacji obiektów R. Należy unikać nazwy zmiennej t, ponieważ jest to funkcja do transpozycji macierzy. Nazwy zmiennych nie mogą zaczynać się od liczby.

Operator fajki

Możesz użyć operatora pipe (%>%) w R, aby “spiąć” razem sekwencję operacji.

Operator ten jest najczęściej używany z pakietem dplyr w R do wykonywania sekwencji operacji na ramce danych.

Podstawowa składnia operatora fajki to:

dane %>% 
  zrób coś %>% 
  a potem zrób jeszcze coś %>%
  a potem wylicz/narysuj...

Operator fajki po prostu przekazuje wyniki jednej operacji do następnej operacji pod nią.

Zaletą stosowania operatora fajki jest to, że czyni on kod niezwykle łatwym do odczytania.

  filter(data, variable == numeric_value)

  data %>% filter(variable == numeric_value)

# zmieniamy nazwy kolumn
mtcars %>%
        head %>%
        set_colnames(paste("Col", 1:11, sep = ""))

##                   Col1 Col2 Col3 Col4 Col5 Col6 Col7 Col8 Col9 Col10 Col11
## Mazda RX4         21.0    6  160  110 3.90 2.62 16.5    0    1     4     4
## Mazda RX4 Wag     21.0    6  160  110 3.90 2.88 17.0    0    1     4     4
## Datsun 710        22.8    4  108   93 3.85 2.32 18.6    1    1     4     1
## Hornet 4 Drive    21.4    6  258  110 3.08 3.21 19.4    1    0     3     1
## Hornet Sportabout 18.7    8  360  175 3.15 3.44 17.0    0    0     3     2
## Valiant           18.1    6  225  105 2.76 3.46 20.2    1    0     3     1

knitr::kable(mtcars, format="html")

mtcars %>%
        filter(carb > 1) %>%
        extract(, 1:4) %>%
        plot() %>%
        summary()

## Length  Class   Mode 
##      0   NULL   NULL

mtcars %>%
        filter(carb > 1) %>%
        extract(, 1:4) %T>%
        plot() %>%
        summary()

##       mpg            cyl            disp           hp     
##  Min.   :10.4   Min.   :4.00   Min.   : 76   Min.   : 52  
##  1st Qu.:15.2   1st Qu.:6.00   1st Qu.:147   1st Qu.:110  
##  Median :17.8   Median :8.00   Median :276   Median :175  
##  Mean   :18.6   Mean   :6.64   Mean   :258   Mean   :164  
##  3rd Qu.:21.0   3rd Qu.:8.00   3rd Qu.:351   3rd Qu.:205  
##  Max.   :30.4   Max.   :8.00   Max.   :472   Max.   :335

mtcars$mpg %<>% sqrt

head(mtcars)

##                    mpg cyl disp  hp drat   wt qsec vs am gear carb
## Mazda RX4         4.58   6  160 110 3.90 2.62 16.5  0  1    4    4
## Mazda RX4 Wag     4.58   6  160 110 3.90 2.88 17.0  0  1    4    4
## Datsun 710        4.77   4  108  93 3.85 2.32 18.6  1  1    4    1
## Hornet 4 Drive    4.63   6  258 110 3.08 3.21 19.4  1  0    3    1
## Hornet Sportabout 4.32   8  360 175 3.15 3.44 17.0  0  0    3    2
## Valiant           4.25   6  225 105 2.76 3.46 20.2  1  0    3    1

knitr::kable(mtcars, format="html")

mtcars %>%
        subset(vs == 0) %>%
        cor(mpg, wt)
## Error in pmatch(use, c("all.obs", "complete.obs", "pairwise.complete.obs", : object 'wt' not found

mtcars %>%
        subset(vs == 0) %$%
        cor(mpg, wt)

## [1] -0.831

Inne operatory

Oto kilka innych powszechnie używanych operatorów.

jest używany do generowania sekwencji.

1:10

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

%in% jest operatorem zbioru.

“a” %in% c(“x”, “p”, “a”, “c”) sprawdza, czy a jest członkiem zbioru x,p,a,c.

"a" %in% c("x","p","a","c")

## [1] TRUE

Odwrotność również by działała, ale liczba zwróconych elemntów jest teraz inna.

c("x","p","a","c") %in% "a"

## [1] FALSE FALSE  TRUE FALSE

:: jest używany do bezpośredniego dostępu do funkcji z określonego pakietu. Kiedy normalnie wywołujesz funkcję, powiedzmy sum(), R przeszukuje przestrzeń nazw i znajduje ją. W przypadku, gdy istnieje funkcja sum() z innego pakietu, ostatnio załadowany pakiet zastępuje poprzednią funkcję. W takich przypadkach lub aby być całkowicie pewnym, że używasz właściwej funkcji z właściwego pakietu, możesz użyć package::function() do wywołania funkcji. Na przykład; base::sum(). ::: jest używane do wywoływania funkcji z pakietu, które nie są “eksportowane”. Jest to rzadko używane.

%*% jest używane do mnożenia macierzy.

matrix(c(2,2,3,3),nrow=2) %*% matrix(c(4,2,5,3),nrow=2)

##      [,1] [,2]
## [1,]   14   19
## [2,]   14   19

matrix(c(2,2,3,3),nrow=2) %*% c(6,6)

##      [,1]
## [1,]   30
## [2,]   30

Operacje na datach

Operacje na datach i format daty nie są takie proste i oczywiste jak by się wydawało.

Proszę prześledź kilka poniższych przykładów operacji z datami.

x <- "2013-04-03"
# Jaka jest struktura x?
str(x)

##  chr "2013-04-03"

# Użyj as.Date() aby zmienić format na datę
x_date <- as.Date(x)
str(x_date)

##  Date[1:1], format: "2013-04-03"

# Zamień April 10 2014 jako datę
april_10_2014 <- as.Date("2014-04-10")

Użyjmy pakietu readr. Co wykonują poniższe czynności?

as.POSIXct("2010-10-01 12:12:00")

## [1] "2010-10-01 12:12:00 CEST"

as.POSIXct("2010-10-01 12:12:00", tz = "America/Los_Angeles")

## [1] "2010-10-01 12:12:00 PDT"

Bardzo przydatny jest pakiet “lubridate” dla operacji z datami.

library(lubridate)
x <- "2010 September 20th" # 2010-09-20
ymd(x)

## [1] "2010-09-20"

y <- "02.01.2010"  # 2010-01-02
dmy(y)

## [1] "2010-01-02"

z <- "Sep, 12th 2010 14:00"  # 2010-09-12T14:00
mdy_hm(z)

## [1] "2010-09-12 14:00:00 UTC"

Możemy także w dowolny sposób manipulować formatem wyświetlania dat.

# Kolejność:
x <- "Monday June 1st 2010 at 4pm"
parse_date_time(x, orders = "amdyIp")

## [1] "2010-06-01 16:00:00 UTC"

two_orders <- c("October 7, 2001", "October 13, 2002", "April 13, 2003",  "17 April 2005", "23 April 2017")
parse_date_time(two_orders, orders = c("mdy","dmy"))

## [1] "2001-10-07 UTC" "2002-10-13 UTC" "2003-04-13 UTC" "2005-04-17 UTC"
## [5] "2017-04-23 UTC"

short_dates <- c("11 December 1282", "May 1372", "1253")
myorders <- c("dOmY", "OmY", "Y")
parse_date_time(short_dates, orders = myorders)

## [1] "1282-12-11 UTC" "1372-05-01 UTC" "1253-01-01 UTC"

Funkcje pakietu lubridate pozwalają nam również zaokrąglać formaty dat.

r_3_4_1 <- ymd_hms("2016-05-03 07:13:28 UTC")
# Zaokrąglij w dół do dni
floor_date(r_3_4_1, unit = "day")

## [1] "2016-05-03 UTC"

# Zaokrąglij do 5 minut
round_date(r_3_4_1, unit = "5 minutes")

## [1] "2016-05-03 07:15:00 UTC"

# Zaokrąglij do tygodni 
ceiling_date(r_3_4_1, unit = "week")

## [1] "2016-05-08 UTC"

# Odejmij od r_3_4_1 ją samą i zaokrąglij do dni
r_3_4_1 - floor_date(r_3_4_1, unit = "day")

## Time difference of 7.22 hours

Rozpatrzmy funkcje obliczeniowe dat:

# Lądowanie na księżycu :)
date_landing <- mdy("July 20, 1969")
moment_step <- mdy_hms("July 20, 1969, 02:56:15", tz = "UTC")
# Ile dni już upłynęło??
difftime(today(), date_landing, units = "days")

## Time difference of 19478 days

# Ile sekund?
difftime(now(),moment_step, units = "secs")

## Time difference of 1682960518 secs

Możemy łatwo obliczać różnice między datami:

# 3 daty
mar_11 <- ymd_hms("2017-03-11 12:00:00", 
  tz = "America/Los_Angeles")
mar_12 <- ymd_hms("2017-03-12 12:00:00", 
  tz = "America/Los_Angeles")
mar_13 <- ymd_hms("2017-03-13 12:00:00", 
  tz = "America/Los_Angeles")
# Różnica pomiędzy mar_13 oraz mar_12 w sekundach
difftime(mar_13, mar_12, units = "secs")

## Time difference of 86400 secs

Możemy również manipulować datami, dodawać lub odejmować okresy:

# Dodaj jeden tydzień do mon_2pm
mon_2pm <- dmy_hm("27 Aug 2018 14:00")
mon_2pm + weeks(1)

## [1] "2018-09-03 14:00:00 UTC"

# Dodaj 81 godzin do tue_9am
tue_9am <- dmy_hm("28 Aug 2018 9:00")
tue_9am + dhours(81)

## [1] "2018-08-31 18:00:00 UTC"

# Odejmij 5 lat od today()
today() - years(5)

## [1] "2017-11-17"

# Odejmij 5 lat od today()
today() - dyears(5)

## [1] "2017-11-16 18:00:00 UTC"

Możemy również manipulować sekwencjami:

# Dodaj 8 godzin:
today_8am <- today() + hours(8)
# Sekwencja 1 do 26:
every_two_weeks <- 1:26 * weeks(2)
# Utwórz sekwencję dat co 2 tygodnie przez rok:
every_two_weeks  + today_8am

##  [1] "2022-12-01 08:00:00 UTC" "2022-12-15 08:00:00 UTC"
##  [3] "2022-12-29 08:00:00 UTC" "2023-01-12 08:00:00 UTC"
##  [5] "2023-01-26 08:00:00 UTC" "2023-02-09 08:00:00 UTC"
##  [7] "2023-02-23 08:00:00 UTC" "2023-03-09 08:00:00 UTC"
##  [9] "2023-03-23 08:00:00 UTC" "2023-04-06 08:00:00 UTC"
## [11] "2023-04-20 08:00:00 UTC" "2023-05-04 08:00:00 UTC"
## [13] "2023-05-18 08:00:00 UTC" "2023-06-01 08:00:00 UTC"
## [15] "2023-06-15 08:00:00 UTC" "2023-06-29 08:00:00 UTC"
## [17] "2023-07-13 08:00:00 UTC" "2023-07-27 08:00:00 UTC"
## [19] "2023-08-10 08:00:00 UTC" "2023-08-24 08:00:00 UTC"
## [21] "2023-09-07 08:00:00 UTC" "2023-09-21 08:00:00 UTC"
## [23] "2023-10-05 08:00:00 UTC" "2023-10-19 08:00:00 UTC"
## [25] "2023-11-02 08:00:00 UTC" "2023-11-16 08:00:00 UTC"

Funkcje podstawowe

Poniżej przedstawiono kilka funkcji, które można zastosować do danych liczbowych:

# wygeneruj 10 liczb losowych z zakresu od 1 do 200
x <- sample(x=1:200,10)

# długość
length(x)

## [1] 10

# suma
sum(x)

## [1] 755

# średnia
mean(x)

## [1] 75.5

# mediana
median(x)

## [1] 67

# minimum
min(x)

## [1] 15

# logarytm
log(x)

##  [1] 4.23 3.81 3.89 4.37 2.71 4.17 4.64 4.76 3.09 5.25

# exponent
exp(x)

##  [1]                                                      925378172558778718688878002176
##  [2]                                                                34934271057485094912
##  [3]                                                              1907346572495099789312
##  [4]                                                 20382810665126688239604997451415552
##  [5]                                                                             3269017
##  [6]                                                       16948892444103337803358666752
##  [7]                                      1467662230155442385345160162931037779871662080
##  [8]                                 649313425566446212204527603098723999605535388205056
##  [9]                                                                          3584912846
## [10] 32805870153846704713003703822495292426493650066588991738813532693125184167792869376

# pierwiastek
sqrt(x)

##  [1]  8.31  6.71  7.00  8.89  3.87  8.06 10.20 10.82  4.69 13.78

# zaokrąglanie
round(x) 

##  [1]  69  45  49  79  15  65 104 117  22 190

#Domyślnie zaokrągla wartości do 0 miejsc po #przecinku. Wypróbuj ?round w konsoli dla odmian #round() i sposobów zmiany liczby cyfr do #zaokrąglenia.  

Funkcje użytkowe

R posiada kilka funkcji do żonglowania strukturami danych:

seq(): Generuje sekwencje, określając argumenty from, to, oraz by.

rep(): Replikuj elementy wektorów i list.

sort(): Sortuj wektor w porządku rosnącym. Działa na liczbach, ale także na łańcuchach znaków i logikach.

rev(): Odwraca elementy w strukturach danych, dla których zdefiniowano odwracanie.

str(): Wyświetl strukturę dowolnego obiektu R.

append(): Połącz wektory lub listy.

is.*(): Sprawdź klasę obiektu R.

as.*(): Konwertowanie obiektu R z jednej klasy na inną.

unlist(): Spłaszcz (ewentualnie osadzone) listy, aby uzyskać wektor.

Funkcje tekstowe

Kilka przydatnych funkcji związanych z ciągami znaków:

a <- "sunny"
b <- "day"

# połącz
paste(a, b)

## [1] "sunny day"

# odnajdź wzór
grep("sun", a)

## [1] 1

# liczba znaków
nchar("sunny")

## [1] 5

# do dużej litery
toupper("sunny")

## [1] "SUNNY"

# do małej litery
tolower("SUNNY")

## [1] "sunny"

# zamiana wzoru
sub("sun", "fun", "sunny")

## [1] "funny"

# podciąg
substr("sunny", start=1, stop=3)

## [1] "sun"

# Wektor maili został już zdefiniowany dla Ciebie:
emails <- c("john.doe@ivyleague.edu", "education@world.gov", "dalai.lama@peace.org",
            "invalid.edu", "quant@bigdatacollege.edu", "cookie.monster@sesame.tv")

# Użyj grepl() aby dopasować dla "edu"
grepl(pattern = "edu", x = emails)

## [1]  TRUE  TRUE FALSE  TRUE  TRUE FALSE

# Użyj grep() aby dopasować dla "edu", zapisz wynik do hits
 
hits <- grep(pattern = "edu", x = emails)

# Podzestaw emaili używając hits
emails[hits]

## [1] "john.doe@ivyleague.edu"   "education@world.gov"     
## [3] "invalid.edu"              "quant@bigdatacollege.edu"

# Wektor emaili został już zdefiniowany dla Ciebie
emails <- c("john.doe@ivyleague.edu", "education@world.gov", "dalai.lama@peace.org",
            "invalid.edu", "quant@bigdatacollege.edu", "cookie.monster@sesame.tv")

# Użyj grepl() aby dopasować adresy .edu bardziej solidnie
grepl(pattern = "@.edu$", x = emails)

## [1] FALSE FALSE FALSE FALSE FALSE FALSE

# Użyj grep(), aby dopasować adresy .edu bardziej solidnie, zapisując wynik w hits
hits <- grep(pattern = "@.*edu$", x = emails)

# Podzestaw emaili używając hits
emails[hits]

## [1] "john.doe@ivyleague.edu"   "quant@bigdatacollege.edu"

# Wektor emails został już zdefiniowany dla Ciebie
emails <- c("john.doe@ivyleague.edu", "education@world.gov", "global@peace.org",
"invalid.edu", "quant@bigdatacollege.edu", "cookie.monster@sesame.tv")

# Użyj sub() aby przekonwertować domeny email na pg.edu.pl
sub(pattern = "@*.edu$", replacement = "@pg.edu.pl", x = emails)

## [1] "john.doe@ivyleague@pg.edu.pl"   "education@world.gov"           
## [3] "global@peace.org"               "invalid@pg.edu.pl"             
## [5] "quant@bigdatacollege@pg.edu.pl" "cookie.monster@sesame.tv"

emails

## [1] "john.doe@ivyleague.edu"   "education@world.gov"     
## [3] "global@peace.org"         "invalid.edu"             
## [5] "quant@bigdatacollege.edu" "cookie.monster@sesame.tv"

# Dlaczego nie wymieniono wszystkich adresów??? ;-)
# Wymienione zostały jedynie te które miały edu w nazwie

awards <- c("Won 1 Oscar.",
  "Won 1 Oscar. Another 9 wins & 24 nominations.",
  "1 win and 2 nominations.",
  "2 wins & 3 nominations.",
  "Nominated for 2 Golden Globes. 1 more win & 2 nominations.",
  "4 wins & 1 nomination.")

# Co zwraca ten fragment kodu?
sub(".*\\s([0-9]+)\\snomination.*$", "\\1", awards)

## [1] "Won 1 Oscar." "24"           "2"            "3"            "2"           
## [6] "1"

#fragment kodu zwraca ilość nominacji "pobierając liczbę, która znajduje się przed słowem nomination

Funkcje ogólne

Kilka ogólnych funkcji:

print("hello")

## [1] "hello"

print("world")

## [1] "world"

cat("hello")

## hello

cat(" world")

##  world

cat("\nhello\nworld")

## 
## hello
## world

Jeśli widzisz, że kopiujesz fragment kodu R wiele razy, to prawdopodobnie dobrym pomysłem jest stworzenie z niego funkcji.

Załóżmy, że masz dwa wektory, na których chciałbyś wykonać serię operacji, a następnie wyprowadzić wynik.

a <- 1:6
b <- 8:10

d <- a*b
e <- log(d)
f <- sqrt(e)
f

## [1] 1.44 1.70 1.84 1.86 1.95 2.02

Możesz zmodyfikować ten blok kodu w funkcję w następujący sposób:

my_function <- function(a, b){
  d <- a*b
  e <- log(d)
  f <- sqrt(e)
  return(f)
}

Po zdefiniowaniu możesz użyć tego, gdziekolwiek jest to potrzebne:

my_function(a=2:4, b=6:8)

## [1] 1.58 1.74 1.86

Zmienne zdefiniowane wewnątrz funkcji są dostępne tylko wewnątrz tej funkcji i nie są dostępne poza nią, chyba że zostaną zwrócone:

my_new_function <- function(a) {
  varz <- a + 2
  return(varz)
}

my_new_function(5)

## [1] 7

#print(varz) # zmienne zdefiniowane w funkcji nie są dostępne poza funkcją, wyświetli się error

W powyższej funkcji zmienna varz utworzona wewnątrz funkcji nie jest dostępna poza nią.

Możliwa jest jednak sytuacja odwrotna:

my_new_function <- function() {
  varz <- foo + 2
  return(varz)
}

foo <- 55
my_new_function()

## [1] 57

W powyższym przykładzie zmienna foo użyta wewnątrz funkcji nie jest dostarczona do funkcji poprzez argument, a mimo to udaje się ją znaleźć. Gdy funkcja nie znajduje zmiennej wewnątrz funkcji, szuka jej poza nią.

Funkcje warunkowe

Instrukcje warunkowe pisze się za pomocą if().

a <- 2
b <- 5

if(a < b) print(paste(a,"jest mniejsze od",b))

## [1] "2 jest mniejsze od 5"

else służy do dodania alternatywnego wyjścia:

a <- 2
b <- 5

if(a < b) {
  print(paste(a,"jest mniejsze od",b))
}else{
  print(paste(b,"jest mniejsze od",a))
}

## [1] "2 jest mniejsze od 5"

a <- 60
b <- 10

if(a < b) {
  print(paste(a,"jest mniejsze od",b))
}else{
  print(paste(b,"jest mniejsze od",a))
}

## [1] "10 jest mniejsze od 60"

instrukcje if else mogą być łączone w łańcuchy:

grade <- "B"

if(grade == "A"){
  print("Ocena jest bardzo dobra!")
}else if(grade == "B"){
  print("Ocena jest dobra.")
} else if (grade == "C") {
  print("Ocena dostateczna.")
}

## [1] "Ocena jest dobra."

Nie należy tego mylić z funkcją o nazwie ifelse(). Jest ona również używana do wyboru warunkowego i przyjmuje postać ifelse(test, return-if-yes, return-if-no), a to jest wektorowe. Tak więc, na przykład, oto kilka wieków osób. Sklasyfikuj je jako dorosłych lub młodocianych.

x <- c(6,23,12,10,56,44)
ifelse(x>18,"Dorosły", "Młodociany")

## [1] "Młodociany" "Dorosły"    "Młodociany" "Młodociany" "Dorosły"   
## [6] "Dorosły"

Pętla for() jest przydatna do wielokrotnego uruchamiania poleceń przez znaną liczbę iteracji.

for (i in 1:5){
  print(i)
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Pętla while() jest przydatna do wielokrotnego uruchamiania poleceń przez nieznaną liczbę iteracji, aż do spełnienia jakiegoś warunku.

i <- 1
while(i < 5){
  print(i)
  i <- i+1
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4