Zpět na přehled cvičení

Rkový skript ke stažení: R

Co si zde představíme?

Matematické funkce

Pro připomenutí funkce c() sdružuje hodnoty do vektoru. Matematické funkce jsou definovány často po složkách, proto do nich můžeme tyto vektory vkládat. Funkce se pak aplikuje na všechny prvky zvlášť.

1 + c(-1,0,pi)    # i standardní operace +,-,*,/ lze provádět po složkách
## [1] 0.000000 1.000000 4.141593

Nejprve si projdeme číselné typy a všechny hodnoty, kterých může funkce nabývat. Jedna ze skvělých věcí na Rku je ta, že se o číselné typy stará samo.

c(TRUE, FALSE, T, F)                        # boolean=logical (lze jen první písmena)
## [1]  TRUE FALSE  TRUE FALSE
2 + c(TRUE, FALSE)                          # považuje TRUE=1 a FALSE=0 
## [1] 3 2
is.logical(1)                               # jedná se o logical hodnotu?
## [1] FALSE
is.numeric(1)                               # jedná se o reálné číslo?
## [1] TRUE
is.integer(1)                               # čísla jsou automaticky považována za reálná (numeric)!
## [1] FALSE
is.integer(as.integer(1))                   # ale lze z nich udělat celá čísla (integer)
## [1] TRUE
is.numeric(as.integer(1))                   # i integer je považován za numeric
## [1] TRUE
as.integer(3.5)                             # usekává desetinná místa
## [1] 3
floor(3.5); ceiling(3.5)                    # dolní, horní celá část
## [1] 3
## [1] 4
trunc(3.5)                                  # nejbližší integer směrem k 0
## [1] 3
floor(c(3.5, -3.5)); trunc(c(3.5, -3.5))    # porovnejte rozdíl
## [1]  3 -4
## [1]  3 -3
round(c(3.49, 3.5, pi))                     # zaokrouhlení
## [1] 3 4 3
round(c(-3.49, -3.5, -pi), digits = 1)      # zaokrouhlení na 1 desetinné místo
## [1] -3.5 -3.5 -3.1
round(c(-3.49, -3.5, -pi), digits = 5)      # zaokrouhlení na 5 desetinných míst, ale pozor na print!
## [1] -3.49000 -3.50000 -3.14159
print(round(c(-3.49, -3.5, -pi), digits = 5), digits = 10) 
## [1] -3.49000 -3.50000 -3.14159
signif(c(-0.049, -3.49, -pi), digits = 2)   # zaokrouhlení čísel na daný počet platných číslic
## [1] -0.049 -3.500 -3.100
c(1.23e3, 1e3)                              # vědecký zápis čísel
## [1] 1230 1000
c(.123, .999)                               # 0 před desetinným číslem lze vynechat
## [1] 0.123 0.999

Máme ale také spousty jiných hodnot, se kterými umí Rko pracovat:

Inf      # +nekonečno
## [1] Inf
-Inf     # -nekonečno
## [1] -Inf
NaN      # Not a Number - nedefinovaný výraz
## [1] NaN
NA       # Not Available - hodnota není dostupná
## [1] NA
c(1, pi, 1/0, -1/0, 0/0, NA)
## [1] 1.000000 3.141593      Inf     -Inf      NaN       NA
is.finite(c(1, pi, 1/0, -1/0, 0/0, NA))
## [1]  TRUE  TRUE FALSE FALSE FALSE FALSE
is.infinite(c(1, pi, 1/0, -1/0, 0/0, NA))
## [1] FALSE FALSE  TRUE  TRUE FALSE FALSE
is.nan(c(1, pi, 1/0, -1/0, 0/0, NA))
## [1] FALSE FALSE FALSE FALSE  TRUE FALSE
is.na(c(1, pi, 1/0, -1/0, 0/0, NA))
## [1] FALSE FALSE FALSE FALSE  TRUE  TRUE
0 * c(1, pi, 1/0, -1/0, 0/0, NA)
## [1]   0   0 NaN NaN NaN  NA
Inf - Inf
## [1] NaN

Spousta matematických funkcí je v Rku předdefinována. Začněme se základními operacemi s čísly::

abs(c(-1,0,2))              # absolutní hodnota
## [1] 1 0 2
10 %% 3                     # zbytek po dělení
## [1] 1
10 %/% 3                    # celočíselné dělení
## [1] 3
3^3; 3**3                   # mocnina
## [1] 27
## [1] 27
c(0,-1,2.5)^3               # jedna mocnina pro všechny
## [1]  0.000 -1.000 15.625
c(0,0,-1)^c(0,Inf,2.5)      # speciální případy, každý se svou mocninou
## [1]   1   0 NaN
9999^99                     # po překročení jistého prahu už jsou vysoká čísla považována za Inf
## [1] Inf
sqrt(c(-1, 0, 16))          # odmocnina
## Warning in sqrt(c(-1, 0, 16)): NaNs produced
## [1] NaN   0   4
x <- 1
1 + x^2 - 4*x^3 + 0.5*x^4   # polynom v jedné hodnotě x
## [1] -1.5
x <- c(-2,1,0,1,2)
1 + x^2 - 4*x^3 + 0.5*x^4   # polynom ve vícero hodnotách x
## [1]  45.0  -1.5   1.0  -1.5 -19.0

Exponenciála a logaritmy:

exp(c(-Inf, 0, 1, Inf))          # Eulerovo číslo jako základ
## [1] 0.000000 1.000000 2.718282      Inf
log(exp(1))                      # automaticky přirozený základ 
## [1] 1
log(c(-Inf, 0, 1, Inf))          # speciální hodnoty
## Warning in log(c(-Inf, 0, 1, Inf)): NaNs produced
## [1]  NaN -Inf    0  Inf
log2(8); log10(100)              # speciální funkce pro konkrétní základy
## [1] 3
## [1] 2
log(c(16,27,1), base = c(4,3,1)) # jiné základy
## Warning: NaNs produced
## [1]   2   3 NaN
log1p(c(-1,0,0.001,1))           # log(1+x) - přesné i pro |x|<<1
## [1]         -Inf 0.0000000000 0.0009995003 0.6931471806
expm1(c(-1,0,0.001,1))           # exp(x)-1 - přesné i pro |x|<<1
## [1] -0.6321206  0.0000000  0.0010005  1.7182818
print(log1p(0.000001), digits = 15)
## [1] 9.99999500000333e-07
print(log(1.000001), digits = 15)
## [1] 9.99999499918067e-07

Trigonometrické funkce:

cos(2*pi); cospi(2)                       # třeba pronásobit pi × netřeba
## [1] 1
## [1] 1
sin(c(-Inf, 0, Inf))                      # nemá limity v nekonečnu
## Warning in sin(c(-Inf, 0, Inf)): NaNs produced
## [1] NaN   0 NaN
tanpi(c(-1.5, -1, -0.5, 0, 0.5, 1, 1.5))  # nedefinované 0.5*pi + k*pi
## Warning in tanpi(c(-1.5, -1, -0.5, 0, 0.5, 1, 1.5)): NaNs produced
## [1] NaN   0 NaN   0 NaN   0 NaN
acos(c(-1.5, -1, -0.5, 0, 0.5, 1, 1.5))   # arc cos
## Warning in acos(c(-1.5, -1, -0.5, 0, 0.5, 1, 1.5)): NaNs produced
## [1]      NaN 3.141593 2.094395 1.570796 1.047198 0.000000      NaN
asin(c(-1.5, -1, -0.5, 0, 0.5, 1, 1.5))   # arc sin
## Warning in asin(c(-1.5, -1, -0.5, 0, 0.5, 1, 1.5)): NaNs produced
## [1]        NaN -1.5707963 -0.5235988  0.0000000  0.5235988  1.5707963        NaN
atan(c(-Inf, -1.5, -1, 0, 1, 1.5, Inf))   # arc tan
## [1] -1.5707963 -0.9827937 -0.7853982  0.0000000  0.7853982  0.9827937  1.5707963
atan2(c(-2,0,6), 2)                       # dva argumenty! atan2(y,x) = atan(y / x)
## [1] -0.7853982  0.0000000  1.2490458

Funkce spojené s minimem a maximem:

max(c(1,2,3,-1,-5, 3))           # maximum z množiny zadaných čísel 
## [1] 3
which.max(c(1,2,3,-1,-5, 3))     # PRVNÍ index položky, která maximalizuje
## [1] 3
min(c(1,NA,2))                   # nezná jedno z čísel, výsledkem je opět NA
## [1] NA
min(c(1,NA,2), na.rm = TRUE)     # ignoruj neznámá čísla
## [1] 1
min(c(-1, 0/0, 1))               # NaN narušuje stejně jako NA
## [1] NaN
min(c(-1, 0/0, 1), na.rm= T)     # na.rm=T také zabírá
## [1] -1
min(c(-Inf, 0, Inf))             # minimem může být i -nekonečno
## [1] -Inf
max(c(-Inf, 0, Inf))             # maximem může být i +nekonečno
## [1] Inf
 min(c(1,3,Inf,3), c(5,1,9,-10)) # akceptuje vícero argumentů, ale vždy vrátí jen jedno číslo
## [1] -10
pmin(c(1,3,Inf,3), c(5,1,9,-10)) # 2 argumenty o stejné délce, pro každý pár vrací menší ze dvou čísel
## [1]   1   1   9 -10
range(c(1,2,3,-1,-5, 3))         # vrací současně min a max hodnoty
## [1] -5  3

Vektory a posloupnosti

S vektory a posloupnostmi utvořenými pomocí c() jsme již pracovali výše. Ale existuje řada specifických funkcí, které s nimi pracují nebo je vytváří:

c(1,2,3,4,5)                 # prvních 5 číslic
## [1] 1 2 3 4 5
1:5                          # alternativně pomocí : značící rozsah
## [1] 1 2 3 4 5
-3:pi                        # lze i pro reálné čísla
## [1] -3 -2 -1  0  1  2  3
-3.8:pi                      # k -3.8 se postupně přičítá 1, dokud je výsledek menší než pi
## [1] -3.8 -2.8 -1.8 -0.8  0.2  1.2  2.2
seq(from=-3.8, to=pi, by=1)  # to samé jako výše, jen argument "by" koriguje výšku skoku
## [1] -3.8 -2.8 -1.8 -0.8  0.2  1.2  2.2
seq(0, 1, 0.1)               # aritmetická posloupnost s přírůstkem 0.1
##  [1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
seq(0, 1, length.out = 21)   # aritmetická posloupnost o počtu "length.out" členů
##  [1] 0.00 0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00
pi:-3                        # klesající aritmetická posloupnost o skoku 1 (první číslo vyšší než druhé)
## [1]  3.1415927  2.1415927  1.1415927  0.1415927 -0.8584073 -1.8584073 -2.8584073
rev(1:5)                     # převrácení vektoru (reverse)
## [1] 5 4 3 2 1
rep(1, 5)                    # opakuj číslo 1 celkem 5×
## [1] 1 1 1 1 1
rep(c(1,2), 5)               # opakuj vektor (1,2) za sebou 5×
##  [1] 1 2 1 2 1 2 1 2 1 2
rep(c(1,2), each = 5)        # opakuj každý prvek vektoru 5×
##  [1] 1 1 1 1 1 2 2 2 2 2
rep(1:4, 1:4)                # opakuj první prvek 1×, druhý 2×, třetí 3×, čtvrtý 4× (vyžaduje stejnou délku obou vektorů)
##  [1] 1 2 2 3 3 3 4 4 4 4
length(-3.8:pi)              # délka vektoru
## [1] 7
sum(1:5)                     # součet vektoru
## [1] 15
mean(1:5)                    # průměr hodnot vektoru
## [1] 3
cumsum(1:5)                  # kumulativní součet prvků vektoru
## [1]  1  3  6 10 15
cumsum(1:5)/(1:5)            # postupné průměry
## [1] 1.0 1.5 2.0 2.5 3.0
prod(1:5)                    # součin prvků vektoru (zde faktoriál)
## [1] 120
cumprod(1:5)                 # vektor postupných součinů
## [1]   1   2   6  24 120

Indexování vektoru začíná od 1 (narozdíl od Pythonu)!

x <- c(1,-1,5,4,3,3)
x[1]                         # první prvek vektoru
## [1] 1
x[2:4]                       # druhý až čtvrtý prvek vektoru
## [1] -1  5  4
x[pi:5]                      # lze dávat i desetinná čísla, interně se nejprve zavolá as.integer()
## [1] 5 4
as.integer(pi:5)
## [1] 3 4
# x[3:-1]                    # nefunguje jako v Pythonu! Rko nezná negativní indexy
x[3:length(x)]               # od indexu do konce vektoru
## [1] 5 4 3 3
x[1:3]                       # od začátku do indexu vektoru
## [1]  1 -1  5
# symbol - má jiné využití, odebere dané prvky (ale všechny indexy musí být záporné)
x[-3]                        # vektor BEZ třetí položky
## [1]  1 -1  4  3  3
x[-c(1,2,3)]                 # vektor BEZ prvních tří členů
## [1] 4 3 3
x[-(1:3)]                    # BEZ závorky nefunguje (chápe jako záporná čísla)
## [1] 4 3 3
x[seq(1,3,by=0.25)]          # indexy se mohou opakovat, výsledek je vektor o stejné délce jako vektor indexů
## [1]  1  1  1  1 -1 -1 -1 -1  5

Jednotlivé prvky vektoru si lze pojmenovat a indexovat pomocí jejich názvů

names(x) <- c("a", "b", "c", "d", "e", "f")
x                            # vektor se tiskne i se zvolenými jmény jednotlivých položek
##  a  b  c  d  e  f 
##  1 -1  5  4  3  3
x[c("a", "f")]               # vybrání konkrétních dvou prvků
## a f 
## 1 3
names(x) <- c("a", "a", "b", "a", "b", "c")
x["a"]                       # při shodě jmen ale nevrací všechny JEN PRVNÍ prvek
## a 
## 1

Vybírat podvektor lze také pomocí stejně dlouhého vektoru logical hodnot:

x[rep(T, length(x))]      # takto vybere všechno
##  a  a  b  a  b  c 
##  1 -1  5  4  3  3
x[c(T,F,T,F,T,F)]         # vybere jen ty prvky, kde je TRUE
## a b b 
## 1 5 3
x[x<=3]                   # vybere jen ty prvky, které splňují zadanou podmínku (díky vektorizaci)
##  a  a  b  c 
##  1 -1  3  3

Vektory lze chápat také jako množiny a provádět s nimi klasické operace:

x <- 1:5                        # x <- c("a", "b", "c", "cC") # funguje i se stringy
y <- 4:7                        # y <- c("cC", "A", "bB")
union(x, y)                     # sjednocení množin x a y
## [1] 1 2 3 4 5 6 7
setdiff(x, y)                   # prvky v x, které nejsou v y
## [1] 1 2 3
setdiff(y, x)                   # prvky v y, které nejsou v x
## [1] 6 7
intersect(x, y)                 # průnik množin x a y
## [1] 4 5
setequal(x, y)                  # jsou množiny x a y shodné?
## [1] FALSE
is.element(1, x)                # je prvek 1 v množině x?
## [1] TRUE
is.element(1:7, x)              # jsou prvky 1 až 7 v množině x?
## [1]  TRUE  TRUE  TRUE  TRUE  TRUE FALSE FALSE
x %in% y                        # které prvky x jsou obsaženy v y?
## [1] FALSE FALSE FALSE  TRUE  TRUE
unique(c(1,1,1.000001,2,2,3))   # unikátní prvky množiny
## [1] 1.000000 1.000001 2.000000 3.000000

Do vektoru lze přidávat nové hodnoty následovně:

(x <- c(x, 6, 7))                 # přetvořením vektoru znovu pomocí c
## [1] 1 2 3 4 5 6 7
append(x, 8)                      # pomocí funkce append, která ale vytváří nový vektor
## [1] 1 2 3 4 5 6 7 8
x                                 # x zůstalo nezměněno
## [1] 1 2 3 4 5 6 7
(x <- append(x, 8))               # teď teprve proběhla změna proměnné x
## [1] 1 2 3 4 5 6 7 8
append(x, values = 0, after = 1)  # připiš mi k x 0 za současnou pozici 1
## [1] 1 0 2 3 4 5 6 7 8
(x <- append(x, 0, 0))            # připiš 0 na začátek vektoru a ulož to jako nové x
## [1] 0 1 2 3 4 5 6 7 8

Všimněte si, že při používání funkce o více argumentech mohu ignorovat názvy proměnných, ale jen pokud si jsem jistý, že vím, v jakém pořadí funkce přijímá argumenty. Nejsem-li si jist, tak doporučuji přiřazovat argument přímo rovnítkem, v tom případě nemusím dodržovat pořadí argumentů. Ještě přesněji, prvních několik argumentů mohu udávat bez přiřazení, dokud vím, v jakém pořadí vystupují, pokud už u dalších proměnných pořadí nevím, nebo nějaké přeskakuji (chci tedy použít defaultní nastavení), tak použiji přiřazením hodnoty k názvu argumentu.

Třídění hodnot ve vektoru se provádí pomocí sort() či order()

x <- c(1,-1,5,4,3,3)
sort(x)                 # seřadí čísla od nejnižší po nejvyšší
## [1] -1  1  3  3  4  5
sort(x, decreasing = T) # seřadí čísla od nejvyšší po nejnižší
## [1]  5  4  3  3  1 -1
order(x)                # pořadí indexů (permutace na 1:length(x))
## [1] 2 1 5 6 4 3
x[order(x)]             # to samé jako sort(x)
## [1] -1  1  3  3  4  5

Matice a práce s nimi

Matice mají svou vlastní třídu matrix, kam se prvky vkládají po sloupcích:

matrix(nrow = 2, ncol = 3)                             # 2×3 "prázdná" matice 
##      [,1] [,2] [,3]
## [1,]   NA   NA   NA
## [2,]   NA   NA   NA
matrix(0, nrow = 2, ncol = 3)                          # 2×3 nulová matice
##      [,1] [,2] [,3]
## [1,]    0    0    0
## [2,]    0    0    0
matrix(c(1,2,3,4,5,6), nrow = 2, ncol = 3)             # 2×3 matice, po sloupcích
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6
matrix(c(1,2,3,4,5,6), nrow = 3, ncol = 2)             # 3×2 matice, po sloupcích
##      [,1] [,2]
## [1,]    1    4
## [2,]    2    5
## [3,]    3    6
matrix(c(1,2,3,4,5,6), nrow = 2, ncol = 3, byrow = T)  # 2×3 matice, po řádcích
##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6
X <- matrix(c(1,2,3,4,5,6), nrow = 2, ncol = 3)
class(X)                                               # třída matrix, nutná pro maticové operace 
## [1] "matrix" "array"
is.matrix(X)                                           # ověření, zda jde o matici
## [1] TRUE
as.matrix(c(1,2,3,4,5,6))                              # převedení vektoru na sloupcový vektor třídy matrix  
##      [,1]
## [1,]    1
## [2,]    2
## [3,]    3
## [4,]    4
## [5,]    5
## [6,]    6

Matici lze vytvořit i kombinováním vektorů:

cbind(1:2, 3:4, 5:6)  # c=column (pospojování přes sloupce)
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6
rbind(1:3, 4:6)       # r=row    (pospojování přes řádky)
##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6

Indexování v matici funguje obdobně jako u vektorů, jen je třeba oddělovat dimenze čárkou:

X[5]                      # bez čárky chápe jako dlouhý vektor, zde tedy 5. prvek, bráno po sloupcích
## [1] 5
X[1,2]                    # prvek na pozici řádek=1, sloupec=2
## [1] 3
X[1:2,1]                  # prvky na řádcích 1 a 2 ve sloupci 1
## [1] 1 2
X[1:2,2:3]                # podmatice - první dva řádky a 2. a 3. sloupec
##      [,1] [,2]
## [1,]    3    5
## [2,]    4    6
X[,2]                     # výběr prvků ve druhém sloupci (jako vektor, ne podmatice!)
## [1] 3 4
X[,2, drop=F]             # drop=FALSE zachovává původní rozměry objektu i při snížení dimenzionality
##      [,1]
## [1,]    3
## [2,]    4
X[2,, drop=F]             # 2. řádek zachovaný jako řádkový vektor
##      [,1] [,2] [,3]
## [1,]    2    4    6
X[,-2]                    # matice bez 2. sloupce
##      [,1] [,2]
## [1,]    1    5
## [2,]    2    6
upper.tri(X, diag = T)    # indexy pro horní trojúhelník s diagonálou
##       [,1] [,2] [,3]
## [1,]  TRUE TRUE TRUE
## [2,] FALSE TRUE TRUE
X[upper.tri(X, diag = T)] # prvky z horního trojúhelníku s diagonálou (po sloupcích)
## [1] 1 3 4 5 6
X[lower.tri(X, diag = F)] # prvky z dolního trojúhelníku bez diagonály (po sloupcích)
## [1] 2

Řádky a sloupce si lze pojmenovat a indexovat pomocí toho:

Y <- matrix(seq(-1,2,length.out=15), nrow = 3, ncol = 5,
            dimnames = list(c("Alois", "Božena", "Cecílie"),       # jména řádků
                            c("x","3","weight","height","age")))   # jména sloupců
Y                # matice s pojmenovanými řádky a sloupci
##                  x           3    weight    height      age
## Alois   -1.0000000 -0.35714286 0.2857143 0.9285714 1.571429
## Božena  -0.7857143 -0.14285714 0.5000000 1.1428571 1.785714
## Cecílie -0.5714286  0.07142857 0.7142857 1.3571429 2.000000
Y["Alois",]      # vektor pojmenovaný sloupci
##          x          3     weight     height        age 
## -1.0000000 -0.3571429  0.2857143  0.9285714  1.5714286
Y[,"age"]        # vektor pojmenovaný řádky
##    Alois   Božena  Cecílie 
## 1.571429 1.785714 2.000000
Y[,3]            # 3. sloupec
##     Alois    Božena   Cecílie 
## 0.2857143 0.5000000 0.7142857
Y[,"3"]          # sloupec pojmenovaný "3"
##       Alois      Božena     Cecílie 
## -0.35714286 -0.14285714  0.07142857

Spousta funkcí akceptuje i matice a provádí operace po složkách:

pi + X
##          [,1]     [,2]     [,3]
## [1,] 4.141593 6.141593 8.141593
## [2,] 5.141593 7.141593 9.141593
abs(X - 3)
##      [,1] [,2] [,3]
## [1,]    2    0    2
## [2,]    1    1    3
cospi(X)
##      [,1] [,2] [,3]
## [1,]   -1   -1   -1
## [2,]    1    1    1
range(X)      # minimum a maximum ze všech prvků
## [1] 1 6
mean(X)       # průměr všech čísel
## [1] 3.5
length(X)     # celkový počet prvků v matici
## [1] 6
dim(X)        # řád matice (počet řádků a počet sloupců)
## [1] 2 3

Základní maticové operace:

rowSums(Y); rowMeans(Y)              # součty/průměry v řádcích
##    Alois   Božena  Cecílie 
## 1.428571 2.500000 3.571429
##     Alois    Božena   Cecílie 
## 0.2857143 0.5000000 0.7142857
colSums(Y); colMeans(Y)              # součty/průměry ve sloupcích
##          x          3     weight     height        age 
## -2.3571429 -0.4285714  1.5000000  3.4285714  5.3571429
##          x          3     weight     height        age 
## -0.7857143 -0.1428571  0.5000000  1.1428571  1.7857143
t(X)                                 # transpozice matice
##      [,1] [,2]
## [1,]    1    2
## [2,]    3    4
## [3,]    5    6
X %*% Y                              # maticové násobení (dědí názvy sloupců)
##              x          3   weight   height      age
## [1,] -6.214286 -0.4285714 5.357143 11.14286 16.92857
## [2,] -8.571429 -0.8571429 6.857143 14.57143 22.28571
X * X                                # obyčejné "*" je násobení po složkách
##      [,1] [,2] [,3]
## [1,]    1    9   25
## [2,]    4   16   36
X %*% as.matrix(1:3)                 # násobení matice sloupcovým vektorem
##      [,1]
## [1,]   22
## [2,]   28
c(-1:1) %*% as.matrix(1:3)           # skalární součin dvou vektorů maticově
##      [,1]
## [1,]    2
sum(-1:1 * 1:3)                      # skalární součin dvou vektorů (výsledek je číslo)
## [1] 2
outer(-1:1, 1:3)                     # vnější součin dvou vektorů 
##      [,1] [,2] [,3]
## [1,]   -1   -2   -3
## [2,]    0    0    0
## [3,]    1    2    3
-1:1 %o% 1:3                         # vnější součin dvou vektorů ale jako binární operace
##      [,1] [,2] [,3]
## [1,]   -1   -2   -3
## [2,]    0    0    0
## [3,]    1    2    3
diag(Y)                              # diag(matice)  vrátí prvky na diagonále matice Y
## [1] -1.0000000 -0.1428571  0.7142857
diag(1:3)                            # diag(vektor)  vytvoří diagonální matici s danými prvky na diagonále
##      [,1] [,2] [,3]
## [1,]    1    0    0
## [2,]    0    2    0
## [3,]    0    0    3
diag(3)                              # diag(číslo)   vytvoří diagonální jednotkovou matici o daném rozměru
##      [,1] [,2] [,3]
## [1,]    1    0    0
## [2,]    0    1    0
## [3,]    0    0    1
(Z = X %*% t(X))                     # X * X^T je pozitivně definitní matice 2×2, tedy regulární
##      [,1] [,2]
## [1,]   35   44
## [2,]   44   56
solve(Z)                             # inverze čtvercové matice
##           [,1]      [,2]
## [1,]  2.333333 -1.833333
## [2,] -1.833333  1.458333
solve(Z, as.matrix(c(79,100)))       # vyřeší soustavu Ax = b
##      [,1]
## [1,]    1
## [2,]    1
eigen(Z)                             # vlastní čísla a vektory
## eigen() decomposition
## $values
## [1] 90.7354949  0.2645051
## 
## $vectors
##           [,1]       [,2]
## [1,] 0.6196295 -0.7848945
## [2,] 0.7848945  0.6196295
qr(X)                                # QR rozklad matice X (horní trojúhelník = R, dolní trojúhelník = Q)
## $qr
##            [,1]       [,2]      [,3]
## [1,] -2.2360680 -4.9193496 -7.602631
## [2,]  0.8944272 -0.8944272 -1.788854
## 
## $rank
## [1] 2
## 
## $qraux
## [1] 1.4472136 0.8944272 1.7888544
## 
## $pivot
## [1] 1 2 3
## 
## attr(,"class")
## [1] "qr"
svdX = svd(X)                        # Singular Value Decomposition = Singulární rozklad
svdX$u %*% diag(svdX$d) %*% t(svdX$v)# X = U * D * V^T
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6
all.equal(eigen(Z)$values, svdX$d^2) # druhá mocnina singulárních čísel X jsou vlastní čísla Z
## [1] TRUE
chol(Z)                              # Choleského rozklad pozitivně definitní matice 
##         [,1]      [,2]
## [1,] 5.91608 7.4373574
## [2,] 0.00000 0.8280787
chol2inv(chol(Z))                    # inverzní matice pomocí Choleského rozkladu
##           [,1]      [,2]
## [1,]  2.333333 -1.833333
## [2,] -1.833333  1.458333

Vícerozměrné objekty (tenzory)

Zde se pro práci s tenzory používá array, který funguje na obdobném principu jako matrix, ale může mít vyšší počet rozměrů:

(tenzor <- array(1:(2*3*5), dim = c(5,3,2)))
## , , 1
## 
##      [,1] [,2] [,3]
## [1,]    1    6   11
## [2,]    2    7   12
## [3,]    3    8   13
## [4,]    4    9   14
## [5,]    5   10   15
## 
## , , 2
## 
##      [,1] [,2] [,3]
## [1,]   16   21   26
## [2,]   17   22   27
## [3,]   18   23   28
## [4,]   19   24   29
## [5,]   20   25   30
dim(tenzor)
## [1] 5 3 2

Všimněte si, že 3D objekt vypisuje Rko po tzv. “řezech” (maticích) v poslední proměnné. Práce s nimi je už složitější a nad rámec kurzu.

Úložky na procvičení

Vyřešte si to sami, aniž byste se dívali do řešení (úplně dole vespod skriptu).

  1. Uvažujte vektor x reálných čísel a napočítejte vektor d prvních diferencí (přírůstků oproti předchozí hodnotě).
  2. Uvažujte vektor x reálných čísel a napočítejte středy intervalů mezi jeho sousedícími čísly.
  3. Pomocí rep zaplňte matici těmi samými řádky či naopak sloupci.
  4. Pomocí rep vytvořte matici o třech sloupcích, tak aby