Pakiet R w analizie układów złożonych

LABORATORIUM 1

• Komendy
• Instrukcja przypisania
• Typy danych: atomowe
  1. Typ liczbowy
  2. Typ znakowy
  3. Typ logiczny
• Typy danych: struktury danych
  1. Wektor
  2. Typ czynnikowy:
  3. Lista
  4. Macierz
  5. Ramka danych
• Indeksy
• Funkcje obsługi wektorów

• w linii komend komendy wpisujemy, kończąc klawiszem Enter,
• aby uruchomić kod z konsoli, zaznaczamy go i używamy kombinacji klawiszy CTRL+Enter,


Przykład 1.1

> 2+2
[1] 4


• średnik ; rozdziela kolejne komendy w linii,


Przykład 1.2

> 3-3; cos(0)
[1] 0
[1] 1


• tekst wypisany w linii po znaku # jest niewidoczny


Przykład 1.3

# wartosc exp(0)
exp(0)
[1] 1

• istnieją trzy sposoby przypisania:

  = <- ->

• w większości przypadków nie ma różnicy, którego operatora używamy


Przykład 1.4

> a=128
> a
[1] 128
> b <- 128
> b
[1] 128
> 128 -> d
> d
[1] 128


• operator = służy do podawania parametrów funkcji,
• uznaje się <- ma wyższy priorytet, co ilustruje poniższy przykład:


Przykład 1.5

a = b <- 5
a; b
[1] 5
[1] 5
# Usuniecie zmiennych a i b
rm(list = c("a","b"))
a <- b = 5
Error in a <- b = 5 : object 'a' not found

1. TYP LICZBOWY

   • liczby całkowite, rzeczywiste oraz zespolone
   • aby zapisać liczbę całkowitą należy na końcu liczby dodać literę L
   • aby zapisać liczbę zespoloną należy użyć formatu a+bi
   • dozwolona notacja naukowa (np. a <- 2.3e3)
   • korzystając z funckji typeof() możemy dowiedzieć się jaki jest typ zmiennej
   
   
   Przykład 1.6
   
   a <- 10
   a; typeof(a)
   [1] 10
   [1] "double"
   b <- 10L
   b; typeof(b)
   [1] 10
   [1] "integer"
   typeof(b+1)
   [1] "double"
   typeof(b+1L)
   [1] "integer"
   d <- 2+3i
   d; typeof(d)
   [1] 2+3i
   [1] "complex"
   sqrt(-1)
   [1] NaN
   Warning message: In sqrt(-1) : NaNs produced
   sqrt(-1+0i)
   [1] 0+1i
   
   
   • specjalnymi wartościami są NaN ("nie liczba") oraz nieskończoności Inf, -Inf
   Przykład 1.7
   
   1/0; exp(-Inf); 0 * Inf
   [1] Inf
   [1] 0
   [1] NaN

2. TYP ZNAKOWY

   • napisy (łańcuchy znaków)
   • rozpoczynają się i kończą znakiem ' lub "
   
   
   Przykład 1.8
   
   > a <- "a"; a
   [1] "a"
   a <- 'Pakiet R'; a
   typeof(a)
   [1] "Pakiet R"
   [1] "character"
   
   
   • zmienna znakowa NIE jest wektorem znaków

3. TYP LOGICZNY

   • reprezentuje logiczną prawdę (TRUE lub T) i fałsz (FALSE lub F)
   • w wyrażeniu arytmetycznym jest automatycznie konwertowany na liczby (odpowiednio (1 i 0)
   
   
   Przykład 1.9
   
   1 == 7
   [1] FALSE
   z <- 1 == 1
   z; typeof(z)
   [1] TRUE
   [1] "logical"
   z <- (1 == 1) + 1
   z; typeof(z)
   [1] 2
   [1] "double"

1. WEKTOR

   • uporządkowany zbiór obiektów tego samego typu (wyjątek NA - brak wartości),
   • podstawowy typ w języku R: operacje wykonywane na wektorach są możliwe najbardziej efektywne.

   Metody tworzenia wektorów:

   • przypisanie,
   
   
   Przykład 1.10
   
   # b juz jest zdefiniowanym wektorem
   > a <- b
   
   
   • funkcja c() do tworzenia z pojedynczych elementów,
   
   
   Przykład 1.11
   
   > a <- c(2, 181, 3.5, 2); a
   [1] 2.0 181.0 3.5 2.0
   
   
   • podanie zakresu za pomocą : lub seq(),
   
   
   Przykład 1.12
   
   > a <- 1:10; a
   [1] 1 2 3 4 5 6 7 8 9 10
   > a <- seq(2, 10, 2); a
   [1] 2 4 6 8 10
   
   
   • powtórzenie za pomoca rep()
   
   
   Przykład 1.13
   
   > a <- rep(T, 10); a
   [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE
   
   
   • złożenie powyższych operacji
   
   
   Przykład 1.14
   
   > a <- rep(seq(2,10,2), 3); a
   [1] 2 4 6 8 10 2 4 6 8 10 2 4 6 8 10

2. TYP CZYNNIKOWY (FAKTOROWY, WYLICZENIOWY, KATEGORYCZNY)

   • przydatny do przechowywania wektorów wartości, występujących na kilku poziomach,
   • służą do reprezentacji danych kategorycznych
   • konstruktor factor(), funkcja levels() wypisuje poziomy
   
   
   Przykład 1.15
   
   wyksztalcenie <- factor(c("podstawowe", "wyzsze", "srednie", "srednie", "wyzsze"))
   wyksztalcenie
   [1] podstawowe wyzsze srednie srednie wyzsze
   Levels: podstawowe srednie wyzsze
   levels(wyksztalcenie)
   [1] "podstawowe" "srednie" "wyzsze"
   
   
   • zajmuje mniej pamięci niż odpowiadający mu typ znakowy - przechowywany jest jako kolejne liczby naturalne, ale nie można na nich wykonywac operacji arytmetycznych
   
   
   Przykład 1.16
   
   typeof(wyksztalcenie)
   [1] "integer"
   wyksztalcenie+1
   [1] NA NA NA NA NA
   Warning message: In Ops.factor(wyksztalcenie, 1) : ?+? not meaningful for factors

3. LISTA

   • uprządkowany zbiór obiektów (czyli wektor), ale różnych typów i dowolnej długości
   • konstruktor list()
     Przykład 1.17
     
     L <- list(inty = 1:10, x = 2.71, tekst = c("a", "b", "c"), log = rep(T, 5))
     L
     $inty
     [1] 1 2 3 4 5 6 7 8 9 10
     
     $x
     [1] 2.71
     
     $tekst
     [1] "a" "b" "c"
     
     $log
     [1] TRUE TRUE TRUE TRUE TRUE

4. MACIERZ

   • konstruktorem macierzy (2D) jest matrix(),
   
   
   Przykład 1.18
   
   A <- matrix(0, 2, 3); A

         [,1] [,2] [,3]
   [1,]    0    0    0
   [2,]    0    0    0
   

   A <- matrix(1:8, 4, 2); A

         [,1] [,2]
   [1,]    1    5
   [2,]    2    6
   [3,]    3    7
   [4,]    4    8
   

   A <- matrix(c("a", "b", "c", "d"),2 , 2); A

        [,1] [,2]
   [1,] "a"  "c" 
   [2,] "b"  "d" 
   

   
   
   • w przypadku wielowymiarowych macierzy (D > 2) korzystamy z konstruktora array()
   
   
   Przykład 1.19
   
   A <- array(1:27, dim = c(3,3,3)); A

   , , 1
   
         [,1] [,2] [,3]
   [1,]    1    4    7
   [2,]    2    5    8
   [3,]    3    6    9
   
   , , 2
   
         [,1] [,2] [,3]
   [1,]   10   13   16
   [2,]   11   14   17
   [3,]   12   15   18
   
   , , 3
   
         [,1] [,2] [,3]
   [1,]   19   22   25
   [2,]   20   23   26
   [3,]   21   24   27

5. RAMKA DANYCH (DATA FRAME)

   • lista wektorów o tej samej długości,
   • elementy w każdej kolumnie są tego samego typu,
   • elementy w różnych kolumnach mogą być różnych typów,
   • bardzo często wykorzystywane jako podstawowy typ w różnych pakietach R (np. ggplot2),
   • konstruktor data.frame()
   
   
   Przykład 1.20
   
   ramka <- data.frame(liczby = 5:1, logiczne = T)
   ramka

     liczby logiczne
   1      5     TRUE
   2      4     TRUE
   3      3     TRUE
   4      2     TRUE
   5      1     TRUE

• WEKTORY: W przypadku wektorów korzystając z operatorów c() (względnie c(-)) oraz : możliwe jest wypisywanie zadanych części zmiennych. Poprzedzenie znakiem c() (minus) oznacza, że nie chcemy wypisywać elementów wektora pod tym indeksem.


Przykład 1.21

w <- 1:10
w[1:5]
[1] 1 2 3 4 5
w[-1]
[1] 2 3 4 5 6 7 8 9 10
w[c(1:4, 8)]
[1] 1 2 3 4 8
w[c(-2, -5)]
[1] 1 3 4 6 7 8 9 10


• MACIERZE: tu sytuacja jest identyczna, przy czym powyższe metody odnoszą się do wszystkich wymiarów macierzy


Przykład 1.22

M <- matrix(1:9, 3, 3)
M

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

# pierwszy wiersz
M[1,]
[1] 1 4 7
# pierwsza kolumna
M[,1]
[1] 1 2 3
# dwa pierwsze wiersze
M[1:2,]

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8

# bez pierwszego wiersza
M[-1,]

      [,1] [,2] [,3]
[1,]    2    5    8
[2,]    3    6    9

# bez drugiego wiersza i drugiej kolumny
M[-2,-2]

     [,1] [,2]
[1,]    1    7
[2,]    3    9



• LISTY: listy można indeksować dwojako - zarówno za pomocą indeksów numerycznych podawanych w nawiasach kwadratowych jak i za pomocą nazw poszczególnych zmiennych przy użyciu operatora $ tzn nazwa_listy$nazwa_zmiennej. Warto pamiętać, że pojedynczy nawias kwadratowy daje jedynie przecięcie listy (tzn jest listą) i aby otrzymać ten sam wynik, co w przypadku operatora $, należy użyć nawiasu podwójnego [[...]].


Przykład 1.23

L <- list(inty = 1:10, x = 2.71, tekst = c("a", "b", "c"), log = rep(T, 5))
L$inty
[1] 1 2 3 4 5 6 7 8 9 10
L[1]
$inty
[1] 1 2 3 4 5 6 7 8 9 10
L[[1]]
[1] 1 2 3 4 5 6 7 8 9 10


• RAMKI DANYCH: podobnie wygląda sytuacja z ramkami danych - tu równiez możemy używać zarówno indeksowania tak, jak w macierzy albo za pomocą nazw poszczególnych kolumn.


Przykład 1.24

ramka <- data.frame(liczby = 5:1, logiczne = T)
ramka

  liczby logiczne
1      5     TRUE
2      4     TRUE
3      3     TRUE
4      2     TRUE
5      1     TRUE

ramka[1:3,]

  liczby logiczne
1      5     TRUE
2      4     TRUE
3      3     TRUE

ramka[,2]
[1] TRUE TRUE TRUE TRUE TRUE
ramka$liczby
[1] 5 4 3 2 1


• należy przy tym pamiętać, że we wszystkich wyżej wymienionych przypadkach, jeśli w wyniki indkesowania otrzymujemy wektor, to z definicji dalej możemy go indeksować:


Przykład 1.25

w[6:10][1:2]
[1] 6 7
L[[3]][2:3]
[1] "b" "c"
ramka$liczby[1:3]
[1] 5 4 3

• średnia elementów wektora mean()
• odchylenie standardowe elementów wektora sd()
• odwrócenie kolejności elementów wektora rev()
• suma wszystkich elementów wektora sum()
• suma skumlowana wektora cumsum()
• iloczyn elementów wektora prod()
• skumulowany iloczyn elementów wektora cumprod()
• wartość minimalnego elementu wektora min()
• indeks minimalnego elementu wektora which.min()
• wartość maksymalnego elementu wektora max()
• indeks maksymalnego elementu wektora which.max()
  
  
  Przykład 1.26
  
  x <- c(1:5,0,5:1)
  mean(x)
  [1] 2.727273
  sd(x)
  [1] 1.678744
  rev(x)
  [1] 1 2 3 4 5 0 5 4 3 2 1
  sum(x)
  [1] 30
  cumsum(x)
  [1] 1 3 6 10 15 15 20 24 27 29 30
  prod(x)
  [1] 0
  cumprod(x)
  [1] 1 2 6 24 120 0 0 0 0 0 0
  min(x)
  [1] 0
  max(x)
  [1] 5
  which.min(x)
  [1] 6
  which.max(x)
  [1] 5
  
  Należy przy tym zwrócić uwagę, czy w wektorze nie występują elementy NA (brak wartości) - wtedy funkcje nie zwrócą oczekiwanego wyniku, chyba że zostanie zastosowana opcja na.rm=TRUE.
  
  
  Przykład 1.27
  
  y <- c(1, NA, 2, 5, 7)
  sum(y)
  [1] NA
  mean(y)
  [1] NA
  sum(y, na.rm = T)
  [1] 15
  mean(y, na.rm = T)
  [1] 3.75

• which(), która podaje indeksy elementów spełniających określony warunek
  
  
  Przykład 1.28
  
  y <- c(1, NA, 2, 5, 7)
  which(y > 2)
  [1] 4 5
  which(y == 2)
  [1] 3
  
  
  przy czym wywołanie komendy which(y == NA) wyświetli komunikat błedu. Aby poradzić sobie z symbolem NA oraz NaN, +/-Inf należy skorzystać z funkcji is.na(), is.nan(), is.finite() oraz is.infinite(). Do uzyskania indeksów znów używamy funkcji which().
  
  
  Przykład 1.29
  
  z <- c(0/0, NA, 1/0, -1/0, 10, 15); z
  [1] NaN NA Inf -Inf 10 15
  is.na(z)
  [1] TRUE TRUE TRUE FALSE FALSE FALSE FALSE
  is.nan(z)
  [1] TRUE FALSE FALSE FALSE FALSE FALSE FALSE
  is.finite(z)
  [1] FALSE FALSE FALSE FALSE FALSE TRUE TRUE
  is.infinite(z)
  [1] FALSE FALSE FALSE TRUE TRUE FALSE FALSE
  which(is.infinite(z))
  [1] 4 5
  
  
  Należy też pamiętać, że niektóre wyniki można otrzymać bez uciekania się do funkcji which(), stosując po prostu warunki. Na przykład, jeżeli chcemy wypisać wszystkie elementy wektora x większe niż 3, możemy postąpić dwojako
  
  
  Przykład 1.30
  
  x[which(x > 3)]
  [1] 4 5 5 4
  x[x > 3]
  [1] 4 5 5 4


• sort(), porządkująca elementy rosnąco (przy zastosowaniu opcji decreasing=TRUE) - malejąco
  
  
  Przykład 1.31
  
  sort(x)
  [1] 0 1 1 2 2 3 3 4 4 5 5
  sort(x, decreasing=T)
  [1] 5 5 4 4 3 3 2 2 1 1 0
  
  
  Dodanie opcji index=TRUE powoduje stworzenie listy, której pierwszej elementem (x) jest posortowany wektor, drugim zaś (ix) indeksy oryginalnych danych w posortowanym wektorze
  
  
  Przykład 1.32
  
  x.sort <- sort(x, index=T); x.sort
  $x
  [1] 0 1 1 2 2 3 3 4 4 5 5
  
  $ix
  [1] 6 1 11 2 10 3 9 4 8 5 7
  x.sort$x
  [1] 0 1 1 2 2 3 3 4 4 5 5
  x.sort$ix
  [1] 6 1 11 2 10 3 9 4 8 5 7