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:

df %>% 
  do_this_operation %>% 
  then_do_this_operation %>%
  then_do_this_operation ...

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

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

#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

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] 1024

# średnia
mean(x)

## [1] 102

# mediana
median(x)

## [1] 93

# minimum
min(x)

## [1] 15

# logarytm
log(x)

##  [1] 5.21 2.71 4.11 4.34 3.43 4.09 4.69 4.84 5.11 5.27

# exponent
exp(x)

##  [1]      29915081357615968034088626280040688642420666640204446660264882426462624024606060
##  [2]                                                                               3269017
##  [3]                                                           310429793570191987488642480
##  [4]                                                    2758513454523170321222208220620682
##  [5]                                                                        29048849665247
##  [6]                                                           114200738981568423456022466
##  [7]                                      217820388072902057162026244860408446246462008600
##  [8]                              14302079958348104959222224644444422006262404444286260866
##  [9]             1238465736729213237308008808682806260468440226228228828668804404606828422
## [10] 4868822826641319536686244868222686482200040224200448240084844242268084828288802044002

# pierwiastek
sqrt(x)

##  [1] 13.53  3.87  7.81  8.77  5.57  7.75 10.44 11.27 12.88 13.96

# zaokrąglanie
round(x)

##  [1] 183  15  61  77  31  60 109 127 166 195

# sortowanie
sort(x)

##  [1]  15  31  60  61  77 109 127 166 183 195

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"

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)

#print(varz)

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