Hlavní navigace

Programovací jazyk R: práce s maticemi

 Autor: R Core Team
Třetím důležitým datovým typem programovacího jazyka R jsou matice. Dnes se seznámíme s funkcemi ze základní knihovny, které jsou určeny právě pro konstrukci matic, popř. pro jejich další zpracování.
Pavel Tišnovský 10. 9. 2020
Doba čtení: 24 minut

Sdílet

Obsah

1. Programovací jazyk R: práce s maticemi

2. Konstrukce matic funkcí matrix

3. Zaplnění matice po sloupcích vs. po řádcích

4. Pojmenování řádků a sloupců matice

5. Tisk tabulky s názvy měsíců

6. Konstrukce čtvercové jednotkové matice

7. Specifikace hodnoty prvků na hlavní diagonále, nečtvercové matice

8. Horní a dolní trojúhelníkové matice

9. Funkce upper.tri

10. Získání matice s indexy řádků nebo sloupců

11. Transpozice matic

12. Maticový součin

13. Výpočet determinantu matice

14. Výpočet inverzní matice

15. Suma prvků (po řádcích, po sloupcích, všech prvků v matici)

16. Průměr prvků (po řádcích, po sloupcích, všech prvků v matici)

17. Funkce cbind a rbind – konstrukce matice z několika vektorů

18. Spojení matic funkcemi cbind a rbind

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Programovací jazyk R: práce s maticemi

Po vektorech, které jsme si popsali ve druhé části seriálu o programovacím jazyku R a polích popsaných v části třetí si musíme popsat třetí velmi důležitý datový typ tohoto jazyka. Jedná se o matice (matrix), které jsou – na rozdíl od polí – vždy dvojrozměrné a homogenní. Ve standardní knihovně programovacího jazyka R existuje několik funkcí určených pro konstrukci matic i pro jejich zpracování. Některé z těchto funkcí si představíme v dnešním článku; opět přitom použijeme velké množství demonstračních příkladů. Ještě předtím si ale ve stručnosti připomeňme, jaké jsou největší rozdíly mezi poli a maticemi. Vybrané rozdíly mezi těmito datovými typy jsou vypsány v následující tabulce:

# Pole Matice
1 typ array typ matrix
2 1, 2, 3 … N dimenzí striktně dvě dimenze (2D struktura)
3 homogenní typ homogenní typ
4 založeno na jediném vektoru s info o dimenzích složeno ze sady vektorů shodné délky
5 používáno primárně pro uložení dat používáno primárně pro transformaci dat
6 relativně malé množství operací plná sada „maticových“ operací
7 nadmnožina nad maticemi speciální případ pole se dvěma dimenzemi
8 konstruktor array konstruktor matrix
Poznámka: samozřejmě existuje možnost konverzí mezi všemi třemi zmíněnými datovými typy.

2. Konstrukce matic funkcí matrix

Obecné matice, které potřebujeme přímo inicializovat, se konstruují funkcí pojmenovanou matrix:

> help(matrix)
 
matrix                  package:base                   R Documentation
 
Matrices
 
Description:
 
     ‘matrix’ creates a matrix from the given set of values.
 
     ‘as.matrix’ attempts to turn its argument into a matrix.
 
     ‘is.matrix’ tests if its argument is a (strict) matrix.
 
Usage:
 
     matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE,
            dimnames = NULL)
 
     as.matrix(x, ...)
     ## S3 method for class 'data.frame'
     as.matrix(x, rownames.force = NA, ...)
 
     is.matrix(x)
 
Arguments:
 
    data: an optional data vector (including a list or ‘expression’
          vector).  Non-atomic classed R objects are coerced by
          ‘as.vector’ and all attributes discarded.
 
    nrow: the desired number of rows.
 
    ncol: the desired number of columns.
 
   byrow: logical. If ‘FALSE’ (the default) the matrix is filled by
          columns, otherwise the matrix is filled by rows.

Této funkci se typicky předává zdroj dat (což může být a většinou i bývá vektor) a v pojmenovaných parametrech nrow a ncol rozměry nově konstruované matice, tj. počet řádků a počet sloupců. Vytvářet lze (pochopitelně) i nečtvercové matice. Funkci konstruktoru matrix si ukážeme na demonstračním příkladu:

> data <- 1:12
>
> m1 <- matrix(data, nrow=1, ncol=12)
> print(m1)
     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12]
[1,]    1    2    3    4    5    6    7    8    9    10    11    12
>
> m2 <- matrix(data, nrow=2, ncol=6)
> print(m2)
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    3    5    7    9   11
[2,]    2    4    6    8   10   12
>
> m3 <- matrix(data, nrow=3, ncol=4)
> print(m3)
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12
>
> m4 <- matrix(data, nrow=4, ncol=3)
> print(m4)
     [,1] [,2] [,3]
[1,]    1    5    9
[2,]    2    6   10
[3,]    3    7   11
[4,]    4    8   12
>
> m5 <- matrix(data, nrow=6, ncol=2)
> print(m5)
     [,1] [,2]
[1,]    1    7
[2,]    2    8
[3,]    3    9
[4,]    4   10
[5,]    5   11
[6,]    6   12
>
> m6 <- matrix(data, nrow=12, ncol=1)
> print(m6)
      [,1]
 [1,]    1
 [2,]    2
 [3,]    3
 [4,]    4
 [5,]    5
 [6,]    6
 [7,]    7
 [8,]    8
 [9,]    9
[10,]   10
[11,]   11
[12,]   12

V případě, že je počet prvků ve zdrojovém vektoru menší, než počet prvků vytvářené matice, jsou prvky opakovány až do chvíle, kdy je matice zaplněna:

data <- c(1, 2, 3)
 
m1 <- matrix(data, nrow=1, ncol=12)
print(m1)
 
m2 <- matrix(data, nrow=2, ncol=6)
print(m2)
 
m3 <- matrix(data, nrow=3, ncol=4)
print(m3)
 
m4 <- matrix(data, nrow=4, ncol=3)
print(m4)
 
m5 <- matrix(data, nrow=6, ncol=2)
print(m5)
 
m6 <- matrix(data, nrow=12, ncol=1)
print(m6)

S výsledky:

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

V mezním případě – pokud použijeme jediný zdrojový prvek – je tento prvek rozkopírován po celé matici. To mj. znamená, že můžeme velmi snadno vytvořit nulové matice libovolného tvaru:

data <- 0
 
m1 <- matrix(data, nrow=1, ncol=12)
print(m1)
 
m2 <- matrix(data, nrow=2, ncol=6)
print(m2)
 
m3 <- matrix(data, nrow=3, ncol=4)
print(m3)
 
m4 <- matrix(data, nrow=4, ncol=3)
print(m4)
 
m5 <- matrix(data, nrow=6, ncol=2)
print(m5)
 
m6 <- matrix(data, nrow=12, ncol=1)
print(m6)

S výsledky:

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12]
[1,]    0    0    0    0    0    0    0    0    0     0     0     0
 
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    0    0    0    0    0    0
[2,]    0    0    0    0    0    0
 
     [,1] [,2] [,3] [,4]
[1,]    0    0    0    0
[2,]    0    0    0    0
[3,]    0    0    0    0
 
     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    0    0
[3,]    0    0    0
[4,]    0    0    0
 
     [,1] [,2]
[1,]    0    0
[2,]    0    0
[3,]    0    0
[4,]    0    0
[5,]    0    0
[6,]    0    0
 
      [,1]
 [1,]    0
 [2,]    0
 [3,]    0
 [4,]    0
 [5,]    0
 [6,]    0
 [7,]    0
 [8,]    0
 [9,]    0
[10,]    0
[11,]    0
[12,]    0
Poznámka: samozřejmě není nutné explicitně používat pojmenovanou proměnnou data – vektor s nulou lze přímo předat konstruktoru matrix.

3. Zaplnění matice po sloupcích vs. po řádcích

V konstruktoru matrix je možné nepovinným parametrem (logickou hodnotou) byrow určit, zda bude matice zaplňována po řádcích nebo po sloupcích. V předchozí kapitole jsme viděli způsob zaplňování po sloupcích (nejprve byl vytvořen celý první sloupec cílové matice, potom druhý sloupec atd.), takže si nyní pro změnu ukažme zaplňování po řádcích. V tomto případě musí být parametr byrow nastaven na pravdivostní hodnotu TRUE:

data <- 1:12
 
m1 <- matrix(data, nrow=1, ncol=12, byrow=TRUE)
print(m1)
 
m2 <- matrix(data, nrow=2, ncol=6, byrow=TRUE)
print(m2)
 
m3 <- matrix(data, nrow=3, ncol=4, byrow=TRUE)
print(m3)
 
m4 <- matrix(data, nrow=4, ncol=3, byrow=TRUE)
print(m4)
 
m5 <- matrix(data, nrow=6, ncol=2, byrow=TRUE)
print(m5)
 
m6 <- matrix(data, nrow=12, ncol=1, byrow=TRUE)
print(m6)

S těmito výsledky (sledujte, jak se prvky mění skutečně nejdříve na prvním řádku, posléze na řádku druhém atd.):

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

4. Pojmenování řádků a sloupců matice

Minule jsme si mj. ukázali, jakým způsobem je možné pojmenovat řádky a sloupce dvojrozměrného pole (resp. přesněji řečeno pole o jakémkoli počtu dimenzí). Podobnou operaci lze provést i s maticemi – konstruktoru matrix postačuje předat v pojmenovaném parametru dimnames seznam vektorů, přičemž první vektor v seznamu obsahuje jména řádků a druhý vektor jména sloupců. Se seznamy jsme se sice prozatím nesetkali, ale ze zdrojového kódu dalšího demonstračního příkladu je patrné, že je jejich konstrukce pomocí list přímočará:

data <- 1:9
dimension.names <- list(
    c("x", "y", "z"),
    c("u", "v", "w"))
 
m33 <- matrix(data, nrow=3, ncol=3, dimnames=dimension.names)
print(m33)

Při tisku obsahu matice se nyní zobrazí námi zvolená jména řádků i sloupců:

  u v w
x 1 4 7
y 2 5 8
z 3 6 9
Poznámka: znovu si připomeňme, že tečka v názvu proměnné nemá (alespoň v tomto případě) žádný speciální význam.

Velikost vektorů musí odpovídat rozměrům matice:

data <- 1:9
dimension.names <- list(
    c("x", "y", "z", "a"),
    c("u", "v", "w"))
 
m33 <- matrix(data, nrow=3, ncol=3, dimnames=dimension.names)
print(m33)

První vektor je o jeden prvek delší, což vede k chybě:

Error in matrix(data, nrow = 3, ncol = 3, dimnames = dimension.names) :
  length of 'dimnames' [1] not equal to array extent
Execution halted

5. Tisk tabulky s názvy měsíců

Díky možnosti pojmenovat řádky a sloupce tabulky můžeme poměrně snadno vytisknout tabulku s názvy měsíců, které budou rozděleny podle ročního období a navíc podle toho, jestli měsíc leží na začátku tohoto období, uprostřed nebo na konci. Samotné zkrácené názvy měsíců obsahuje konstanta nazvaná month.abb ze standardní knihovny a informace o ní pochopitelně nalezneme v nápovědě:

help("month.abb")
 
     R has a small number of built-in constants.
 
     The following constants are available:
 
        • ‘LETTERS’: the 26 upper-case letters of the Roman alphabet;
 
        • ‘letters’: the 26 lower-case letters of the Roman alphabet;
 
        • ‘month.abb’: the three-letter abbreviations for the English
          month names;
 
        • ‘month.name’: the English names for the months of the year;
 
        • ‘pi’: the ratio of the circumference of a circle to its
          diameter.
 
     These are implemented as variables in the base namespace taking
     appropriate values.

Tento vektor si ostatně můžeme vytisknout a prozkoumat:

print(month.abb)
 
 [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"

Nyní již můžeme vytisknout slíbenou tabulku s měsíci. Zdrojový vektor bude nepatrně upravený takovým způsobem, aby začínal prosincem a nikoli lednem (zvýrazněná část zdrojového kódu):

matrix(
  month.abb[c(12, 1:11)],
  nrow = 3,
  dimnames = list(
    c("start", "middle", "end"),
    c("Winter", "Spring", "Summer", "Fall")
  )
)

Výsledek po spuštění tohoto příkladu by měl vypadat následovně:

       Winter Spring Summer Fall
start  "Dec"  "Mar"  "Jun"  "Sep"
middle "Jan"  "Apr"  "Jul"  "Oct"
end    "Feb"  "May"  "Aug"  "Nov"

Podobně existuje i konstanta nazvaná month.name s plnými jmény měsíců:

print(month.name)
 
 [1] "January"   "February"  "March"     "April"     "May"       "June"
 [7] "July"      "August"    "September" "October"   "November"  "December"

I tento zdrojový vektor můžeme použít pro konstrukci tabulky; příklad se přitom změní jen minimálně:

matrix(
  month.name[c(12, 1:11)],
  nrow = 3,
  dimnames = list(
    c("start", "middle", "end"),
    c("Winter", "Spring", "Summer", "Fall")
  )
)

S výsledkem:

       Winter     Spring  Summer   Fall
start  "December" "March" "June"   "September"
middle "January"  "April" "July"   "October"
end    "February" "May"   "August" "November"

6. Konstrukce čtvercové jednotkové matice

Velmi často se v praxi setkáme s požadavkem na vytvoření čtvercové jednotkové matice, tj. takové matice, která obsahuje jedničky na hlavní diagonále a nuly ve všech ostatních prvcích. Jednotková matice dostala svůj název z toho důvodu, že se při maticovém součinu skutečně chová jako jednotka – vynásobením jakékoli matice jednotkovou maticí získáme matici původní (v žádném případě to neplatí o matici, v níž by byly všechny prvky jednotkové).

Čtvercovou jednotkovou matici získáme zavoláním funkce nazvané diag, které předáme jediný parametr – velikost čtvercové matice, tj. počet řádků a současně i počet sloupců. Podívejme se na jednoduchý příklad použití této funkce:

diagonal = diag(10)
print(diagonal)

Po spuštění výše uvedeného demonstračního příkladu by se měla vypsat jednotková matice s deseti řádky a deseti sloupci:

      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
 [1,]    1    0    0    0    0    0    0    0    0     0
 [2,]    0    1    0    0    0    0    0    0    0     0
 [3,]    0    0    1    0    0    0    0    0    0     0
 [4,]    0    0    0    1    0    0    0    0    0     0
 [5,]    0    0    0    0    1    0    0    0    0     0
 [6,]    0    0    0    0    0    1    0    0    0     0
 [7,]    0    0    0    0    0    0    1    0    0     0
 [8,]    0    0    0    0    0    0    0    1    0     0
 [9,]    0    0    0    0    0    0    0    0    1     0
[10,]    0    0    0    0    0    0    0    0    0     1
Poznámka: lze vytvořit i jednotkovou matici s jediným prvkem:
diagonal = diag(1)
print(diagonal)
 
     [,1]
[1,]    1

7. Specifikace hodnoty prvků na hlavní diagonále, nečtvercové matice

Ve skutečnosti jsou možnosti funkce diag, s níž jsme se v její nejjednodušší podobě seznámili v předchozí kapitole, mnohem větší. Pokud totiž této funkci předáme dva parametry, bude první parametr představovat hodnotu/hodnoty na hlavní diagonále a druhý parametr rozměry konstruované matice:

diagonal = diag(-1, 4)
print(diagonal)

Po spuštění příkladu se zobrazí matice 4×4 prvky, která bude na hlavní diagonále obsahovat hodnoty –1; ostatní prvky zůstanou nulové (stále se tedy bude jednat o diagonální matici):

     [,1] [,2] [,3] [,4]
[1,]   -1    0    0    0
[2,]    0   -1    0    0
[3,]    0    0   -1    0
[4,]    0    0    0   -1

Můžeme dokonce specifikovat i oba rozměry matice, tj. počet řádků následovaný počtem sloupců. Opět si uvedeme dva příklady:

diagonal1 = diag(-1, 10, 6)
print(diagonal1)
 
diagonal2 = diag(-1, 6, 10)
print(diagonal2)

Výsledkem budou následující dvě matice, které již nejsou čtvercové:

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

A konečně se podívejme na to, jak lze zkonstruovat matici a přitom specifikovat hodnoty prvků na hlavní diagonále s využitím vektoru. Rozměry matice jsou odvozeny z délky tohoto vektoru:

diagonal1 = diag(1:10)
print(diagonal1)

Výsledná matice:

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

Popř. pro „nepravidelné“ hodnoty:

diagonal1 = diag(c(1,10,2,9,3,8))
print(diagonal1)

Výsledná matice:

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    0    0    0    0    0
[2,]    0   10    0    0    0    0
[3,]    0    0    2    0    0    0
[4,]    0    0    0    9    0    0
[5,]    0    0    0    0    3    0
[6,]    0    0    0    0    0    8

8. Horní a dolní trojúhelníkové matice

V základní knihovně programovacího jazyka R nalezneme i konstruktory trojúhelníkových matic. Nejprve se podívejme na funkci nazvanou lower.tri, která nám může pomoci při konstrukci trojúhelníkové matice:

help(lower.tri)
 
lower.tri                 package:base                 R Documentation
 
Lower and Upper Triangular Part of a Matrix
 
Description:
 
     Returns a matrix of logicals the same size of a given matrix with
     entries ‘TRUE’ in the lower or upper triangle.
 
Usage:
 
     lower.tri(x, diag = FALSE)
     upper.tri(x, diag = FALSE)
 
Arguments:
 
       x: a matrix or other R object with ‘length(dim(x)) == 2’.  For
          back compatibility reasons, when the above is not fulfilled,
          ‘as.matrix(x)’ is called first.
 
    diag: logical.  Should the diagonal be included?
 
See Also:
 
     ‘diag’, ‘matrix’; further ‘row’ and ‘col’ on which ‘lower.tri()’
     and ‘upper.tri()’ are built.
 
Examples:
 
     (m2 <- matrix(1:20, 4, 5))
     lower.tri(m2)
     m2[lower.tri(m2)] <- NA
     m2
      

Z popisu uvedeného výše je patrné, že tato funkce nevrací skutečnou trojúhelníkovou matici, ale matici s logickými hodnotami TRUE a FALSE, přičemž hodnoty pod hlavní diagonálou jsou nastaveny na TRUE. Nepovinným parametrem diag lze zvolit hodnoty umístěné na hlavní diagonále:

data <- 1:25
 
m55 <- matrix(data, nrow=5, ncol=5)
print(m55)
 
tri1 <- lower.tri(m55, diag=FALSE)
print(tri1)
 
tri2 <- lower.tri(m55, diag=TRUE)
print(tri2)

Výsledky (trojice matic) získaná po spuštění tohoto demonstračního příkladu:

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

Užitečnost matic s pravdivostními hodnotami spočívá v tom, že takové matice můžeme použít jako výběrovou masku a vytvořit tak horní či dolní trojúhelníkovou matici z jiné matice. Předchozí příklad upravíme tak, že nejdříve vytvoříme obecnou matici 5×5 prvků, dále matici s hodnotami TRUE a FALSE a nakonec z první matice vybereme prvky pod hlavní diagonálou, do kterých se předá nulová hodnota:

data <- 1:25
 
m55 <- matrix(data, nrow=5, ncol=5)
print(m55)
 
print(m55[lower.tri(m55, diag=FALSE)])
 
m55[lower.tri(m55, diag=FALSE)] <- 0
print(m55)

Tento příklad již vypíše skutečnou horní trojúhelníkovou matici, která má pod hlavní diagonálou samé nuly:

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

9. Funkce upper.tri

Funkce upper.tri je obdobou výše popsané funkce lower.tri, slouží ovšem pro konstrukci matice s logickými hodnotami TRUE nad hlavní diagonálou a hodnot FALSE pod diagonálou:

data <- 1:25
 
m55 <- matrix(data, nrow=5, ncol=5)
print(m55)
 
tri1 <- upper.tri(m55, diag=FALSE)
print(tri1)
 
tri2 <- upper.tri(m55, diag=TRUE)
print(tri2)

S výslednými maticemi:

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

Tuto funkci opět můžeme použít pro konstrukci trojúhelníkové matice pomocí maskování:

data <- 1:25
 
m55 <- matrix(data, nrow=5, ncol=5)
print(m55)
 
print(m55[upper.tri(m55, diag=FALSE)])
 
m55[upper.tri(m55, diag=FALSE)] <- 0
print(m55)

Výsledkem nyní bude dolní trojúhelníková matice, která má nad hlavní diagonálou samé nuly:

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

10. Získání matice s indexy řádků nebo sloupců

Další užitečné funkce se jmenují row a col. První z těchto funkcí vrátí matici o stejných rozměrech, jako má matice předaná v parametru, ovšem prvky budou obsahovat čísla řádků. Podobně funkce col vrátí matici s čísly sloupců:

data <- 1:25
 
m55 <- matrix(data, nrow=5, ncol=5)
print(m55)
 
print(row(m55))
print(col(m55))

Výsledek spuštění tohoto příkladu bude vypadat následovně:

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

Tyto funkce nám umožňují tvořit další zajímavé matice:

data <- 1:25
m55 <- matrix(data, nrow=5, ncol=5)
 
print(col(m55) - row(m55))

S výsledkem:

     [,1] [,2] [,3] [,4] [,5]
[1,]    0    1    2    3    4
[2,]   -1    0    1    2    3
[3,]   -2   -1    0    1    2
[4,]   -3   -2   -1    0    1
[5,]   -4   -3   -2   -1    0

atd. atd.

11. Transpozice matic

Transpozici matice zajišťuje funkce nazvaná jednoduše t:

data <- 1:25
 
m55 <- matrix(data, nrow=5, ncol=5)
print(m55)
 
transposed <- t(m55)
print(transposed)

S výsledky:

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

Samozřejmě se nemusíme omezit pouze na čtvercové matice:

data <- 1:24
 
m55 <- matrix(data, nrow=2, ncol=6)
print(m55)
 
transposed <- t(m55)
print(transposed)

Tentokrát budou pochopitelně výsledky odlišné:

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

12. Maticový součin

Důležitou operací, kterou lze s maticemi provádět, je maticový součin. Ten je v programovacím jazyku R představován operátorem %*%, který se vkládá mezi dva operandy, podobně jako všechny ostatní binární operátory:

data <- 1:25
 
m1 <- matrix(data, nrow=5, ncol=5)
print(m1)
 
m2 <- diag(5)
print(m2)
 
print(m1 %*% m2)
 
m2[3,3] <- 10
print(m1 %*% m2)

Výsledek maticového součinu několika matic:

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    6   11   16   21
[2,]    2    7   12   17   22
[3,]    3    8   13   18   23
[4,]    4    9   14   19   24
[5,]    5   10   15   20   25
 
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    0    0    0    0
[2,]    0    1    0    0    0
[3,]    0    0    1    0    0
[4,]    0    0    0    1    0
[5,]    0    0    0    0    1
 
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    6   11   16   21
[2,]    2    7   12   17   22
[3,]    3    8   13   18   23
[4,]    4    9   14   19   24
[5,]    5   10   15   20   25
 
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    6  110   16   21
[2,]    2    7  120   17   22
[3,]    3    8  130   18   23
[4,]    4    9  140   19   24
[5,]    5   10  150   20   25

Opět nejsme omezeni pouze na čtvercové matice:

data <- 1:12
 
m1 <- matrix(data, nrow=4, ncol=3)
print(m1)
 
m2 <- matrix(data, nrow=3, ncol=4)
print(m2)
 
print(m1 %*% m2)
     [,1] [,2] [,3]
[1,]    1    5    9
[2,]    2    6   10
[3,]    3    7   11
[4,]    4    8   12
 
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12
 
     [,1] [,2] [,3] [,4]
[1,]   38   83  128  173
[2,]   44   98  152  206
[3,]   50  113  176  239
[4,]   56  128  200  272

Další příklad, tentokrát pro matici se dvěma řádky a šesti sloupci, která je vynásobena maticí se šesti řádky a dvěma sloupci:

data <- 1:12
 
m1 <- matrix(data, nrow=2, ncol=6)
print(m1)
 
m2 <- matrix(data, nrow=6, ncol=2)
print(m2)
 
print(m1 %*% m2)

Výsledkem je matice o velikosti 2×2 prvky:

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    3    5    7    9   11
[2,]    2    4    6    8   10   12
 
     [,1] [,2]
[1,]    1    7
[2,]    2    8
[3,]    3    9
[4,]    4   10
[5,]    5   11
[6,]    6   12
 
     [,1] [,2]
[1,]  161  377
[2,]  182  434

Prohození první a druhé matice v operaci součinu (maticový součin není komutativní):

data <- 1:12
 
m1 <- matrix(data, nrow=2, ncol=6)
print(m1)
 
m2 <- matrix(data, nrow=6, ncol=2)
print(m2)
 
print(m2 %*% m1)

Výsledky:

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    3    5    7    9   11
[2,]    2    4    6    8   10   12
 
     [,1] [,2]
[1,]    1    7
[2,]    2    8
[3,]    3    9
[4,]    4   10
[5,]    5   11
[6,]    6   12
 
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]   15   31   47   63   79   95
[2,]   18   38   58   78   98  118
[3,]   21   45   69   93  117  141
[4,]   24   52   80  108  136  164
[5,]   27   59   91  123  155  187
[6,]   30   66  102  138  174  210

Pokus o maticový součin s maticemi, jejichž tvar není pro součin vhodný:

data <- 1:12
 
m1 <- matrix(data, nrow=2, ncol=6)
print(m1)
 
m2 <- matrix(data, nrow=4, ncol=3)
print(m2)
 
print(m1 %*% m2)

Chybové hlášení:

data <- 1:12
 
m1 <- matrix(data, nrow=2, ncol=6)
print(m1)
 
m2 <- matrix(data, nrow=6, ncol=2)
print(m2)
 
print(m1 %*% m2)

13. Výpočet determinantu matice

Pro výpočet determinantu matice slouží funkce nazvaná det. Podívejme se na typický příklad použití:

data <- 1:25
 
m1 <- matrix(data, nrow=5, ncol=5)
print(m1)
print(det(m1))
 
m2 <- diag(5)
print(m2)
print(det(m2))

S výsledky (determinant je zvýrazněn):

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

14. Výpočet inverzní matice

Pro výpočet inverzní matice se používá (poměrně překvapivě) funkce nazvaná solve:

data <- c(2, 3, 2, 2)
 
m1 <- matrix(data, nrow=2, ncol=2)
print(m1)
print(solve(m1))
 
m2 <- diag(5)
print(m2)
print(solve(m2))
 
m3 <- diag(5)
m3[3, 3] = 42
print(m3)
print(solve(m3))

Výsledky získané předchozím příkladem:

     [,1] [,2]
[1,]    2    2
[2,]    3    2
 
     [,1] [,2]
[1,] -1.0    1
[2,]  1.5   -1
 
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    0    0    0    0
[2,]    0    1    0    0    0
[3,]    0    0    1    0    0
[4,]    0    0    0    1    0
[5,]    0    0    0    0    1
 
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    0    0    0    0
[2,]    0    1    0    0    0
[3,]    0    0    1    0    0
[4,]    0    0    0    1    0
[5,]    0    0    0    0    1
 
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    0    0    0    0
[2,]    0    1    0    0    0
[3,]    0    0   42    0    0
[4,]    0    0    0    1    0
[5,]    0    0    0    0    1
 
     [,1] [,2]       [,3] [,4] [,5]
[1,]    1    0 0.00000000    0    0
[2,]    0    1 0.00000000    0    0
[3,]    0    0 0.02380952    0    0
[4,]    0    0 0.00000000    1    0
[5,]    0    0 0.00000000    0    1

Kontrola, zda součinem původní matice s maticí inverzní vznikne jednotková matice:

data <- c(2, 3, 2, 2)
 
m1 <- matrix(data, nrow=2, ncol=2)
print(m1)
 
inverse <- solve(m1)
print(inverse)
 
print(m1 %*% inverse)

Výsledek je (prakticky, s přimhouřením oka) skutečně jednotková matice:

     [,1] [,2]
[1,]    2    2
[2,]    3    2
 
     [,1] [,2]
[1,] -1.0    1
[2,]  1.5   -1
 
     [,1]         [,2]
[1,]    1 2.220446e-16
[2,]    0 1.000000e+00

Ne vždy je možné inverzní matici vypočítat:

data <- 0
 
m1 <- matrix(data, nrow=5, ncol=5)
print(m1)
  
print(solve(m1))

Chybové hlášení:

     [,1] [,2] [,3] [,4] [,5]
[1,]    0    0    0    0    0
[2,]    0    0    0    0    0
[3,]    0    0    0    0    0
[4,]    0    0    0    0    0
[5,]    0    0    0    0    0
Error in solve.default(m1) :
  Lapack routine dgesv: system is exactly singular: U[1,1] = 0
Calls: print -> solve -> solve.default
Execution halted

15. Suma prvků (po řádcích, po sloupcích, všech prvků v matici)

Funkce colSums vrátí vektor obsahující součty prvků v jednotlivých sloupcích:

data <- 1:25
 
m1 <- matrix(data, nrow=5, ncol=5)
print(m1)
print(colSums(m1))

Výsledek běhu příkladu:

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

Podobně funkce rowSums vypočte součty prvků na řádcích matice a opět je vrátí ve formě vektoru:

data <- 1:25
 
m1 <- matrix(data, nrow=5, ncol=5)
print(m1)
print(rowSums(m1))

Výsledek běhu příkladu:

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

A konečně funkce sum dokáže mj. vypočítat součet všech prvků v matici:

data <- 1:25
 
m1 <- matrix(data, nrow=5, ncol=5)
print(m1)
print(sum(m1))

Výsledek běhu příkladu:

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

16. Průměr prvků (po řádcích, po sloupcích, všech prvků v matici)

Existuje ještě trojice funkcí určených pro výpočet průměrů, a to opět po řádcích matice, po sloupcích, popř. pro průměr všech prvků v matici. Chování je velmi podobné funkcím popsaným v předchozí kapitole, takže jen ve stručnosti.

Získání vektoru obsahujícího průměrné hodnoty sloupců matice:

data <- 1:25
 
m1 <- matrix(data, nrow=5, ncol=5)
print(m1)
print(colMeans(m1))

Výsledek běhu příkladu:

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

Získání vektoru obsahujícího průměrné hodnoty řádků matice:

data <- 1:25
 
m1 <- matrix(data, nrow=5, ncol=5)
print(m1)
print(rowMeans(m1))

Výsledek běhu příkladu:

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

A konečně výpočet průměru ze všech prvků:

data <- 1:25
 
m1 <- matrix(data, nrow=5, ncol=5)
print(m1)
print(mean(m1))

Výsledek běhu příkladu:

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

Posun hodnot prvků matice tak, aby byl průměr nulový:

data <- 1:25
 
m1 <- matrix(data, nrow=5, ncol=5)
print(m1)
 
offset = mean(m1)
 
m2 <- m1 - offset
print(m2)

Výsledky:

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

17. Funkce cbind a rbind – konstrukce matice z několika vektorů

V dalším příkladu použijeme funkci nazvanou cbind, kterou je možné (mj.) použít pro konstrukci matice z několika vektorů:

vec1 <- 1:10
vec2 <- 11:20
vec3 <- 10:1
 
print(cbind(vec1, vec2, vec3))

Výsledek:

      vec1 vec2 vec3
 [1,]    1   11   10
 [2,]    2   12    9
 [3,]    3   13    8
 [4,]    4   14    7
 [5,]    5   15    6
 [6,]    6   16    5
 [7,]    7   17    4
 [8,]    8   18    3
 [9,]    9   19    2
[10,]   10   20    1

Dtto, ale nyní s využitím funkce rbind:

vec1 <- 1:10
vec2 <- 11:20
vec3 <- 10:1
 
print(rbind(vec1, vec2, vec3))

Výsledek nyní vypadá odlišně:

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
vec1    1    2    3    4    5    6    7    8    9    10
vec2   11   12   13   14   15   16   17   18   19    20
vec3   10    9    8    7    6    5    4    3    2     1

18. Spojení matic funkcemi cbind a rbind

Funkce cbind a rbind nepracují pouze s vektory, ale například i s celými maticemi, které spojuje do matice větší. Ukažme si nejdříve použití cbind:

data <- 1:25
 
m1 <- matrix(data, nrow=5, ncol=5)
print(m1)
 
m2 <- diag(5)
print(m2)
 
print(cbind(m1, m2))

Výsledná matice bude mít stále pět řádků, ale deset sloupců:

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

Použití funkce rbind pro spojení matic po řádcích:

Linuxová školení

data <- 1:25
 
m1 <- matrix(data, nrow=5, ncol=5)
print(m1)
 
m2 <- diag(5)
print(m2)
 
print(rbind(m1, m2))

Tentokrát bude mít výsledná matice pět sloupců (jako matice zdrojové), ovšem deset řádků:

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

19. Repositář s demonstračními příklady

Zdrojové kódy všech dnes použitých demonstračních příkladů byly uloženy do nového Git repositáře, který je dostupný na adrese https://github.com/tisnik/r-examples V případě, že z nějakého důvodu nebudete chtít klonovat celý repositář (ten je ovšem – alespoň prozatím – velmi malý, dnes má stále jen jednotky kilobajtů), můžete namísto toho použít odkazy na jednotlivé demonstrační příklady, které naleznete v následující tabulce:

# Příklad Stručný popis Cesta
1 01-matrix-construction.R konstrukce matic funkcí matrix https://github.com/tisnik/r-examples/blob/master/04-matrix-table/01-matrix-construction.R
2 02-zero-matrix.R konstrukce nulové funkcí matrix https://github.com/tisnik/r-examples/blob/master/04-matrix-table/02-zero-matrix.R
3 03-matrix-construction-by-row.R zaplnění matice po sloupcích vs. po řádcích https://github.com/tisnik/r-examples/blob/master/04-matrix-table/03-matrix-construction-by-row.R
4 04-dimnames.R pojmenování řádků a sloupců matice https://github.com/tisnik/r-examples/blob/master/04-matrix-table/04-dimnames.R
5 05-months-abb.R tisk tabulky se zkrácenýminázvy měsíců https://github.com/tisnik/r-examples/blob/master/04-matrix-table/05-months-abb.R
6 06-months-names.R tisk tabulky s plnými názvy měsíců https://github.com/tisnik/r-examples/blob/master/04-matrix-table/06-months-names.R
7 07-diagonal-square-matrix.R konstrukce čtvercové jednotkové matice https://github.com/tisnik/r-examples/blob/master/04-matrix-table/07-diagonal-square-matrix.R
8 08-diagonal-square-matrix-value.R specifikace hodnoty prvků na hlavní diagonále https://github.com/tisnik/r-examples/blob/master/04-matrix-table/08-diagonal-square-matrix-value.R
9 09-diagonal-non-square-matrix.R konstrukce nečtvercové diagonální matice https://github.com/tisnik/r-examples/blob/master/04-matrix-table/09-diagonal-non-square-matrix.R
10 10-diagonal-range.R konstrukce čtvercové diagonální matice https://github.com/tisnik/r-examples/blob/master/04-matrix-table/10-diagonal-range.R
11 11-lower-tri.R konstrukce trojúhelníkové matice https://github.com/tisnik/r-examples/blob/master/04-matrix-table/11-lower-tri.R
12 12-lower-tri-zeros.R vynulování části pod hlavní diagonálou https://github.com/tisnik/r-examples/blob/master/04-matrix-table/12-lower-tri-zeros.R
13 13-upper-tri.R konstrukce trojúhelníkové matice https://github.com/tisnik/r-examples/blob/master/04-matrix-table/13-upper-tri.R
14 14-upper-tri-zeros.R vynulování části nad hlavní diagonálou https://github.com/tisnik/r-examples/blob/master/04-matrix-table/14-upper-tri-zeros.R
15 15-row-col.R indexy řádků a indexy sloupců https://github.com/tisnik/r-examples/blob/master/04-matrix-table/15-row-col.R
16 16-transpose.R transpozice matice https://github.com/tisnik/r-examples/blob/master/04-matrix-table/16-transpose.R
17 17-multiply.R násobení dvou čtvercových matic https://github.com/tisnik/r-examples/blob/master/04-matrix-table/17-multiply.R
18 18-multiply-non-square.R součin dvou nečtvercových matic https://github.com/tisnik/r-examples/blob/master/04-matrix-table/18-multiply-non-square.R
19 19-multiply-non-square.R součin dvou nečtvercových matic https://github.com/tisnik/r-examples/blob/master/04-matrix-table/19-multiply-non-square.R
20 20-multiply-non-square.R součin dvou nečtvercových matic https://github.com/tisnik/r-examples/blob/master/04-matrix-table/20-multiply-non-square.R
21 21-determinant.R výpočet determinantu matice https://github.com/tisnik/r-examples/blob/master/04-matrix-table/21-determinant.R
22 22-inverse.R výpočet inverzní matice https://github.com/tisnik/r-examples/blob/master/04-matrix-table/22-inverse.R
23 23-colsums.R výpočet sumy podle sloupců https://github.com/tisnik/r-examples/blob/master/04-matrix-table/23-colsums.R
24 24-rowsums.R výpočet sumy podle řádků https://github.com/tisnik/r-examples/blob/master/04-matrix-table/24-rowsums.R
25 25-sum.R výpočet sumy všech prvků matice https://github.com/tisnik/r-examples/blob/master/04-matrix-table/25-sum.R
26 26-colmeans.R výpočet průměru podle sloupců https://github.com/tisnik/r-examples/blob/master/04-matrix-table/26-colmeans.R
27 27-rowmeans.R výpočet průměru podle řádků https://github.com/tisnik/r-examples/blob/master/04-matrix-table/27-rowmeans.R
28 28-mean.R výpočet průměru všech prvků matice https://github.com/tisnik/r-examples/blob/master/04-matrix-table/28-mean.R
29 29-cbind-vector.R funkce cbind aplikovaná na vektory https://github.com/tisnik/r-examples/blob/master/04-matrix-table/29-cbind-vector.R
30 30-cbind-matrix.R funkce cbind aplikovaná na matice https://github.com/tisnik/r-examples/blob/master/04-matrix-table/30-cbind-matrix.R

20. Odkazy na Internetu

  1. The R Project for Statistical Computing
    https://www.r-project.org/
  2. An Introduction to R
    https://cran.r-project.org/doc/manuals/r-release/R-intro.pdf
  3. R (programming language)
    https://en.wikipedia.org/wi­ki/R_(programming_language)
  4. The R Programming Language
    https://www.tiobe.com/tiobe-index/r/
  5. R Markdown
    https://rmarkdown.rstudio.com/
  6. R Markdown: The Definitive Guide
    https://bookdown.org/yihui/rmarkdown/
  7. R Markdown Cheat Sheet
    https://rstudio.com/wp-content/uploads/2016/03/rmarkdown-cheatsheet-2.0.pdf
  8. Introduction to R Markdown
    https://rmarkdown.rstudio­.com/articles_intro.html
  9. R Cheat Sheets
    https://blog.sergiouri.be/2016/07/r-cheat-sheets.html
  10. R Cheat Sheet
    https://s3.amazonaws.com/quandl-static-content/Documents/Quandl±+R+Che­at+Sheet.pdf
  11. Base R Cheat Sheet
    https://rstudio.com/wp-content/uploads/2016/06/r-cheat-sheet.pdf
  12. PYPL PopularitY of Programming Language
    https://pypl.github.io/PYPL.html
  13. Tiobe index
    https://www.tiobe.com/tiobe-index/
  14. Stack Overflow: Most Loved, Dreaded & Wanted Programming Languages In 2020
    https://fossbytes.com/stack-overflow-most-loved-dreaded-wanted-programming-languages-in-2020/
  15. How to Install and Use R on Ubuntu
    https://itsfoss.com/install-r-ubuntu/
  16. R programming for beginners – Why you should use R
    https://www.youtube.com/wat­ch?v=9kYUGMg_14s
  17. GOTO 2012 • The R Language The Good The Bad & The Ugly
    https://www.youtube.com/wat­ch?v=6S9r_YbqHy8
  18. R vs Python – What should I learn in 2020? | R and Python Comparison
    https://www.youtube.com/wat­ch?v=eRP_J2yLjSU
  19. R Programming 101
    https://www.youtube.com/c/rpro­gramming101
  20. Seriál Tvorba grafů pomocí programu „R“
    https://www.root.cz/serialy/tvorba-grafu-pomoci-programu-r/
  21. Tvorba grafů pomocí programu „R“: úvod
    https://www.root.cz/clanky/tvorba-grafu-pomoci-programu-r-1/
  22. Tvorba grafů pomocí programu „R“: pokročilé funkce
    https://www.root.cz/clanky/tvorba-grafu-pomoci-programu-r-pokrocile-funkce/
  23. Tvorba grafů pomocí programu „R“: vkládání textu, čeština
    https://www.root.cz/clanky/grafy-pomoci-programu-r-vkladani-textu-cestina/
  24. Cesta erka: Krok nultý – instalace & nastavení – prostředí, projekty, package
    https://www.jla-data.net/r4su/r4su-environment-setup/
  25. Cesta erka: Krok první – operace a struktury – proměnné, rovnítka a dolary
    https://www.jla-data.net/r4su/r4su-data-structures/
  26. Cesta erka: Krok druhý – načtení externích dat – csvčka, excely a databáze
    https://www.jla-data.net/r4su/r4su-read-data/
  27. Cesta erka: Krok třetí – manipulace s daty – dplyr, slovesa a pajpy
    https://www.jla-data.net/r4su/r4su-manipulate-data/
  28. Cesta erka: Krok čtvrtý – podání výsledků – ggplot, geomy a estetiky
    https://www.jla-data.net/r4su/r4su-report-results/
  29. Cesta erka: Krok pátý – case study – případ piva v Praze
    https://www.jla-data.net/r4su/r4su-case-study-beer/
  30. V indexu popularity programovacích jazyků TIOBE překvapilo R, Go, Perl, Scratch a Rust
    https://www.root.cz/zpravicky/v-indexu-popularity-programovacich-jazyku-tiobe-prekvapilo-r-go-perl-scratch-a-rust/
  31. Is R Programming SURGING in Popularity in 2020?
    https://www.youtube.com/watch?v=Duwn-vImyXE
  32. Using the R programming language in Jupyter Notebook
    https://docs.anaconda.com/a­naconda/navigator/tutorial­s/r-lang/
  33. Using R on Jupyter Notebook
    https://dzone.com/articles/using-r-on-jupyternbspnotebook
  34. Graphics, ggplot2
    http://r4stats.com/examples/graphics-ggplot2/
  35. A Practice Data Set
    https://r4stats.wordpress­.com/examples/mydata/
  36. Shiny – galerie projektů
    https://shiny.rstudio.com/gallery/
  37. Seriál Programovací jazyk Julia
    https://www.root.cz/seria­ly/programovaci-jazyk-julia/
  38. Julia (front page)
    http://julialang.org/
  39. Julia – repositář na GitHubu
    https://github.com/JuliaLang/julia
  40. Julia (programming language)
    https://en.wikipedia.org/wi­ki/Julia_%28programming_lan­guage%29
  41. IJulia
    https://github.com/JuliaLan­g/IJulia.jl
  42. Introducing Julia
    https://en.wikibooks.org/wi­ki/Introducing_Julia
  43. Julia: the REPL
    https://en.wikibooks.org/wi­ki/Introducing_Julia/The_REPL
  44. Introducing Julia/Metaprogramming
    https://en.wikibooks.org/wi­ki/Introducing_Julia/Meta­programming
  45. Month of Julia
    https://github.com/DataWo­okie/MonthOfJulia
  46. Learn X in Y minutes (where X=Julia)
    https://learnxinyminutes.com/doc­s/julia/
  47. New Julia language seeks to be the C for scientists
    http://www.infoworld.com/ar­ticle/2616709/application-development/new-julia-language-seeks-to-be-the-c-for-scientists.html
  48. Julia: A Fast Dynamic Language for Technical Computing
    http://karpinski.org/publi­cations/2012/julia-a-fast-dynamic-language
  49. The LLVM Compiler Infrastructure
    http://llvm.org/
  50. Julia: benchmarks
    http://julialang.org/benchmarks/
  51. R Vector
    https://www.datamentor.io/r-programming/vector/
  52. .R File Extension
    https://fileinfo.com/extension/r
  53. Lineární regrese
    https://cs.wikipedia.org/wi­ki/Line%C3%A1rn%C3%AD_regre­se
  54. lm (funkce)
    https://www.rdocumentation­.org/packages/stats/versi­ons/3.6.2/topics/lm
  55. quit (funkce)
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/quit
  56. c (funkce)
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/c
  57. help (funkce)
    https://www.rdocumentation­.org/packages/utils/versi­ons/3.6.2/topics/help
  58. Shiny: Introduction to interactive documents
    https://shiny.rstudio.com/ar­ticles/interactive-docs.html
  59. R Release History 1997–2013
    http://timelyportfolio.git­hub.io/rCharts_timeline_r/
  60. R: atomic vectors
    https://renenyffenegger.ch/no­tes/development/languages/R/da­ta-structures/vector/
  61. 11 Best R Programming IDE and editors
    https://www.dunebook.com/best-r-programming-ide/
  62. CRAN – The Comprehensive R Archive Network
    https://cran.r-project.org/
  63. R – Arrays
    https://www.tutorialspoin­t.com/r/r_arrays.htm
  64. Array vs Matrix in R Programming
    https://www.geeksforgeeks.org/array-vs-matrix-in-r-programming/?ref=rp
  65. Online R Language IDE
    https://www.jdoodle.com/execute-r-online/
  66. Execute R Online (R v3.4.1)
    https://www.tutorialspoin­t.com/execute_r_online.php
  67. Snippets: Run any R code you like. There are over twelve thousand R packages preloaded
    https://rdrr.io/snippets/
  68. R Package Documentation
    https://rdrr.io/
  69. Data Reshaping in R – Popular Functions to Organise Data
    https://techvidvan.com/tutorials/data-reshaping-in-r/