Univerzita Jana Evangelisty Purkyně v Ústí nad Labem Katedra biologie
Informační technologie v biologických vědách II (Studijní opory pro distanční studium) v. 1.0
Marcel Štofik Ústí nad Labem 2013
Stručný úvod Biologie je součástí přírodních věd, kde se nové poznatky každým dnem rozrůstají o velké množství informací. Prvotním výstupem každého výzkumu jsou naměřená nebo sesbíraná data. Je proto důležité umět se orientovat v oblasti zpracovávání a vyhodnocování experimentálních dat a v tvorbě vhodných grafických výstupů pro jejich prezentaci. Není nutné a prakticky ani není možné znát všechny postupy pro práci s daty. Tím se zabývá samostatný vědní obor statistika a studenti se s tímto oborem seznámí v jiném specializovaném kurzu. Hlavním cílem kurzu je zvládnutí samostatné práce s programem R a příprava grafických výstupů pomocí programu R do publikovatelných grafů s vysokou výstupní kvalitou. Součástí kurzu je také nastínění možností pokročilejších způsobů zpracování experimentálních dat. Aby se studenti mohli seznámit i s komerčními programy, je do kurzu zařazena ukázka práce s komerčně dostupným programem SigmaPlot od společnosti Systat Software, Inc. V průběhu kurzu nebude kladen důraz na kompletní zvládnutí probíraných problémů, ani na memorování jednotlivých příkazů či funkcí programů, se kterými budeme pracovat. Důležité bude naučit se samostatně pracovat s programy a s nápovědou v jednotlivých programech. Probíraná problematika bude prakticky procvičena v průběhu konzultací. Aktivní účast studentů na konzultacích bude tedy důležitá pro zvládnutí ovládání programů a zvládnutí základů probíraných témat.
Marcel Štofik autor textu
Obsah Základy práce s programem R ...............................................................................5 Popis objektů...................................................................................................10 Možnosti výpočtů a práce s operátory ........................................................... 18 Načtení a zápis dat na disk ..............................................................................22 Manipulace s objekty a jejich prvky ................................................................ 24 Vytváření vlastních funkcí, používání cyklů a podmíněných výrazů ...............25 Základy grafiky ................................................................................................ 26 Základní grafika ........................................................................................... 29 Pokročilejší grafika ......................................................................................38 Vybrané možnosti zpracováni dat pomocí programu R .....................................41 Grafické vyhodnocení dotazníku.....................................................................41 Generování dat z rovnoměrného (uniformního) a normálního rozložení ......47 Vytvoření bublinového grafu ..........................................................................50 Vytvoření více os v jednom grafu (2 grafy v jednom) .....................................52 Lineární regresní model ..................................................................................55 Nelineární regresní model ..............................................................................58 Populační model dravec-kořist .......................................................................63 Spektra ELISA testu ......................................................................................... 67 Zpracování dat ze spektrofotometru .............................................................. 71 Vytvoření krabicového grafu...........................................................................73 Stonek a lodyha (stem-and-leave) ..................................................................75 Stripchart.........................................................................................................78 Histogram ........................................................................................................80 Možnosti koláčového grafu.............................................................................82 Úvod k programu SigmaPlot ...............................................................................86 Co je to notebook, notebook manager a základní informace pro práci s programem .....................................................................................................87 Tvorba grafů ....................................................................................................90
Vytváření grafů z definovaných rovnic, vkládaní lineárních a polynomiálních regresí do grafů, tvorba histogramů ............................................................... 93 Report editor ...................................................................................................95 Příprava publikovatelných výstupů .................................................................97 Doporučené studijní zdroje .................................................................................98 Vybrané internetové zdroje ............................................................................98
Základy práce s programem R Jedním z nejlepších programů určených pro zpracování dat, který je dostupný zdarma, je program R. Jeho snad jedinou nevýhodou pro českého uživatele je absence českého pracovní prostředí. Program R je dostupný pro platformu UNIX, MS Windows a Macintosh a jeho hlavní určení je statistické zpracování dat. Program R využívá programovací jazyk R. Ten je velmi podobný s jazykem S, který používá komerční program S-plus. Kromě základních a velmi pokročilých možností statistického zpracování dat, umožňuje program R možnost tvorby velmi kvalitních grafických výstupů zpracovaných dat. Kromě základních funkcí je pro R dostupné velké množství doplňujících balíčků. Ty rozšiřují jak možnosti analýzy a zpracování dat, tak přípravu grafických výstupů. Vzhledem k tomu, že program R je Open Source projekt, na jeho vývoji pracuje neustále mnoho odborníků na zpracování dat. Výhodou programu je možnost využívání různých doplňků, které nejsou nebo ani svou dostupností nemohou být součástí komerčních programů. Protože program R využívá programovací jazyk R, možnost programování jednoduchých i složitých funkcí nabízí pokročilejším uživatelům tvorbu velmi složitých operací s daty a statistické analýzy. Pro program R existuje mnoho volně dostupných studijních materiálů, odborných prací, ale i knih publikovaných velkými vydavatelstvími. Kromě jmenovaných výhod má program R pro běžného uživatele jednu velkou nevýhodu. Tou je nutnost psaní skriptů. Povzbuzením pro učení se práce s programem R je skutečnost, že R má velmi strmou křivku učení, a to co je pro úplného začátečníka téměř nemožné, pro mírně pokročilého uživatele začne být zábava a výzva objevování nových možností v sobě samém. Program R je dostupný na stránkách projektu R www.R-project.org s možností výběru verze programu pro konkrétní operační systém a volbou instalace 32 nebo 64 bitové verze. Pro operační systém jsou k dispozici instalační programy s příponou EXE. Samotná instalace je velmi jednoduchá. Základní balíček obsahuje základní knihovny, dostačující pro začínajícího uživatele. Další nástroje je možné stáhnout z archívu webové aplikace nebo přímo programem. Na následujícím obrázku vidíme internetovou stránku s možností stažení programu pro MS Windows v aktuální verzi 3.0.1.
Po instalaci a spuštění programu je pro uživatele dostupné hlavní okno programu obsahující konsolu – R konsolu. Toto okno slouží k zadávání příkazů a funkcí. Objevují se v něm i základní výstupy zpracovaného programového kódu. Kromě konsoly jsou pro uživatele dostupná ještě některá další okna, ke kterým patří grafické okno – objeví se po spuštění grafické funkce, Editor skriptu (programu), informační okno nebo okno nápovědy. Abychom mohli uživatelsky přehledněji pracovat se samotným programem, je možné instalovat další programy, které slouží jako editory psaného kódu (skriptu) a organizátory grafických oken, se kterými uživatel pracuje. K zajímavým programům z této kategorie patří TinnR nebo RStudio. Postup využití těchto programů je následující. Nejprve se nainstaluje program R. Potom některý ze jmenovaných programů. Po jejich spuštění je program R dostupný přímo v okně daného programu. Velkou výhodou instalace uvedených editorů je přehledné psaní skriptu s možností zvýrazňování jednotlivých funkcí a jejich argumentů, včetně kontroly grafických výstupů. Na následujícím obrázku vidíme ukázku programu TinnR. Nahoře je navigační panel. V levé části je editor skriptu se zapnutým zvýrazňováním zapsaných funkcí a jejich argumentů, poznámek atd. V pravé nahoře části vidíme program R (okno programu) a v pravé dolní části hlášení o chybách skriptu.
Další obrázek ukazuje program RStudio. V levé horní části je umístěn editor skriptů, vlevo dole prostředí programu R. V pravé horní časti je možné procházet historií a zobrazuje se pracovní prostor, se kterým se právě pracuje. V pravé dolní části jsou umístěnyé čtyři záložky (Soubor, Graf, Balíčky a Help).
V případě potřeby dalších funkcí, které nejsou součástí základní instalace programu, je možné automaticky doinstalovat další balíčky, pomocí příkazu install.packages(jmeno_balicku). Balíčky často obsahují sady programového
vybavení. Do programu se načtou příkazem library(nazev_balicku). Příkazem search() je možné zobrazit dostupné balíčky. Obsahem některých knihoven jsou i datové soubory, tzv. data sets. Seznam dostupných datových souborů se zobrazí příkazem data(). Uvedením konkrétního jména datového souboru do závorky umožníme programu načtení jeho obsahu, se kterým můžeme dále pracovat. Obsah datového souboru zobrazíme zapsáním jeho jména do konzoly programu a zmáčknutím klávesy Enter. Naučení se práce s konzolou je základní podmínkou pro ovládání programu a psaní příkazů a funkcí. V základním nastavení konzoly se na začátku každého řádku zobrazuje znak >. Po zapsaní příkazu (funkce) a zmáčknutí klávesy Enter dojde k vykonaní příkazu, viz níže. Funkce print() vytiskne na obrazovku obsah, kterým je v našem případě ˇ´cislo 1.
Obsah konzoly je možné uložit příkazem File -> Save to file, anebo načíst příkazem File > Open. Konzolu je možno vymazat klávesovou zkratkou Ctrl L nebo Edit -> Clear Concole. Obsah konsoly je možno kopírovat a vkládat klávesovými zkratkami Ctrl C, Ctrl V. Ukončení programu je stejné jako u každého jiného programu v systému MS Windows. Výhodou programu R je, že umožňuje ukládání nejenom vytvořených skriptů do jednoduchých textových souborů, ale i ukládání tzv. workspace, pracovního prostoru. S uložením pracovního prostoru se ukládají i veškeré vytvořené a načtené objekty, se kterými program pracoval. Po opětovném otevření pracovního prostoru jsou vytvořený skript i tyto objekty ihned k dispozici. Protože program R používá programovací jazyk R, je důležité zvládnout základní syntaxi programu. Stačí i malá nepozornost v zápisu příkazu a program nebude schopen správně interpretovat zadaný příkaz. Jazyk programu je tzv. case sensitive, což znamená, že rozeznává mezi velkými a malými písmeny. Například print() není totéž co Print(), viz níže.
V případě, že píšeme příkaz, který je velmi dlouhý, a chceme začít psát na novém řádku, použitím klávesy Enter ukončíme psaní na daném řádku a začínáme psát na řádku novém. Někdy se nám může stát, že zadáme dlouhý příkaz, ale výstupem konzoly je nový řádek a znak +, To znamená, že jsme příkaz správně neukončili a program požaduje dokončení psaného příkazu. Text, který v konzole začíná znakem křížek #, znamená poznámku. Spuštění takového příkazu program nijak neinterpretuje. Za většinu příkazů a funkcí je nutné zapsat kulaté závorky (). Do nich se zapisují vlastnosti funkce, tzv. argumenty, které mohou mít různý obsah. Znakem středník ; oddělujeme více příkazů zapsaných v jednom řádku.
Do složených závorek zapisujeme příkazy, které mají následovat těsně za sebou. Často se používají pro psaní funkcí. Podobně jako u kulatých závorek, i obsah složených závorek musí být uzavřen jak zprava tak zleva. Program R obsahuje velké množství příkazů a funkcí, které není možné si zapamatovat. Proto, kromě zvládnutí základní syntaxe, je pro práci s programem důležité naučit se pracovat samostatně s nápovědou, která je velmi podrobná a dostupná jak v PDF, tak v HTML formátu. Nápovědu spustíme zadání help(dane_tema), nebo za otazník ? zapíšeme hledané téma ve formátu ?dane_tema, například nápověda k funkci table() se spustí zadáním ?table(). Výsledek vidíme na obrázku níže.
Jednotlivé vestavěné funkce mají nápovědu ve formátu referencí, které nejčastěji obsahují popis (Description), způsob použití (Usage), seznam argumentů s popisem (Arguments) a možnými hodnotami (Values), autora funkce (Author), odkaz na literaturu (Reference) nebo podobná témata (See also) a příklady k dané funkci nebo příkazu (Examples). Také je možné vyhledávaní v nápovědě, a to pomocí funkce help.search („dane_tema“). Velkou výhodou pro samostatnou práci s programem je alespoň pasivní znalost anglického jazyka, a to z toho důvodu, že pomoc pro řešení téměř jakéhokoliv problému nalezneme v anglickém jazyce a vyhledáme ji zadáním anglických klíčových slov, doplněných výrazem „in R“ v internetovém vyhledávači.
Popis objektů Program R vždy pracuje s objekty. Objektem může být vektor, funkce apod., podrobnosti viz dále v textu. Objekty vytváříme zadáním názvu objektu a přirazením obsahu k objektu. K tomu abychom mohli přiřadit obsah ke konkrétnímu objektu je možno využít funkce assign () nebo soubor znaků
a = 1
> a [1] 1 > b = "B" > b [1] "B" > assign("A", 1:5) > A [1] 1 2 3 4 5
Objekty mohou být konstanty (nemění se) nebo proměnné (mění se) a při vytváření objektů bychom měli dodržovat určitá pravidla. Název objektu by se neměl shodovat s názvem již existujícího objektu a neměl by být příliš dlouhý. Dlouhé názvy je vhodné rozdělovat například tečkou, nikdy ne mezerou. Pozor dáváme na velké a malé písmena. Pro přehlednost je vhodné dodržovat logiku v pojmenování objektů. Každý objekt má určité vlastnosti, na jejichž základě s ním můžeme manipulovat. Dle těchto vlastností může stejná funkce interpretovat dva různé objekty jinak, můžeme tedy získat jiný výstup. Dle souboru vlastností se jednotlivé objekty zařazují do určité třídy (class), módu (mode), případně k určitému typu (typeof). Zjištění těchto vlastností například u objektu x provedeme zadáním příkazu class(x) – zjistíme třídu objektu, mode (x) – zjistíme mód, typeoff(x) – zjistíme typ objektu. Příkazem methods(nazev_funkce) vypíšeme všechny metody přirazené k dané funkci. > class(a); class(b); class(A) [1] "numeric" [1] "character" [1] "integer" > typeof(a); typeof(b); typeof(A) [1] "double" [1] "character" [1] "integer"
Obsah objektu často tvoří jemu přiřazené hodnoty. Mezi základní patří:
Čísla (numeric) mohou být celá (integer), reálná (double), komplexní (complex). Jako oddělovač desetinných míst používáme vždy tečku.
Znak, textový řetězec (character, string), je nutné zapisovat do uvozovek. Objekt faktor používá také znak a řetězec, jsou to však hodnoty nominální škály.
Datum (date), používají se různé formáty a jeho použití může být pro začátečníka komplikovanější.
Logické hodnoty (logical) TRUE nebo FALSE se používají jako atributy některých funkcí a mohou mít zkratku T nebo F. Znamenají pravda nebo nepravda.
Vzorce (formula) se používají při označování různých modelů, grafů a provádějí výpočty. Pro základní zápis vzorce se používá znak tilda ~, y~x znamená, že y je závislé na x.
Další možný obsah objektu jsou chybějící hodnoty označovány jako NA, nekonečno jako Inf, nečíselná hodnota jako NaN (not a number), nebo nulový objekt (nic neobsahuje) jako NULL. Mezi základní objekty, které v programu R používáme, můžeme jmenovat:
Vektory (vector) – představují množiny hodnot. Jako hodnoty je možné použít čísla, znaky, řetězce. Je důležité uvědomit si, že jeden vektor může obsahovat pouze jeden typ hodnot (například jen čísla, jen text apod.) a že každý prvek vektoru má své místo (pořadí). Pro vytváření vektoru můžeme použít následující funkce:
> c(1,2,3,4); c("A","a","B","b"); c(3:1) [1] 1 2 3 4 [1] "A" "a" "B" "b" [1] 3 2 1 > -3:3 [1] -3 -2 -1 0 1 2 3 > seq(from=1, to=5, by=0.5); seq(1:6) [1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 [1] 1 2 3 4 5 6 > seq(length=20, 1, 2) [1] 1.000000 1.052632 1.105263 1.157895 1.210526 1.263158 1.315789 1.368421
[9] 1.421053 1.473684 1.526316 1.578947 1.631579 1.684211 1.736842 1.789474 [17] 1.842105 1.894737 1.947368 2.000000 > rep(1:3, times=2); rep(1:3,each=2) [1] 1 2 3 1 2 3 [1] 1 1 2 2 3 3 > vector(mode = "character", length = 1) # vector s jednim prvkem [1] "" > vector(mode = "logical", length = 0) jenim prvkem logical(0)
# prazdny vector s
> 1<2; 1>2; 1==2 # možnost vytvoření logického vektoru [1] TRUE [1] FALSE [1] FALSE > c(T,F,T,F) # T a F znamená TRUE, FALSE, logické hodnoty [1] TRUE FALSE TRUE FALSE
Matice (matrix) jsou prvky umístěné v řádcích a sloupcích. Prvky obsahují hodnoty matice. V případě, že se při vytváření matice použije méně hodnot, než je prvků v dané matici, následující prvky nabudou opakované hodnoty. Důležité je vědět, že matice se mohou číst po řádcích nebo po sloupcích. Výhodou matic je, že mohou být vícerozměrné (obsahovat dimenze).
> matrix(1:6, nrow=2, ncol=3, byrow=T) [,1] [,2] [,3] [1,] 1 2 3 [2,] 4 5 6 > matrix(1:6, nrow=2, ncol=3, byrow=F) [,1] [,2] [,3] [1,] 1 3 5 [2,] 2 4 6 > matrix(1:6, c(2,3)) [,1] [,2] [,3] [1,] 1 3 5
[2,]
2
4
6
> matrix(1:6, c(2,3), dimnames = list(c("r1", "r2"), c("sl1", "sl2", "sl3"))) sl1 sl2 sl3 r1 1 3 5 r2 2 4 6
Pole (array) jsou jedno nebo vícerozměrné matice, kterým můžeme také přiřazovat různé dimenze.
> array(11:15, dim=c(1), dimnames=list("nm1")) nm1 11 > array(11:15, dim=c(5), dimnames=list(c("nm1","nm2","nm3","nm4","nm5"))) nm1 nm2 nm3 nm4 nm5 11 12 13 14 15 > array(11:15, dim=c(5,2)) [,1] [,2] [1,] 11 11 [2,] 12 12 [3,] 13 13 [4,] 14 14 [5,] 15 15 > array(11:15, dim=c(5,2), dimnames=list(c("nm1","nm2","nm3","nm4","nm5"),c("sl1","sl2 "))) sl1 sl2 nm1 11 11 nm2 12 12 nm3 13 13 nm4 14 14 nm5 15 15 > array(11:15, dim=c(5,2,2), dimnames=list(c("nm1","nm2","nm3","nm4","nm5"),c("sl1","sl2 "),c("False","True"))) # pole se trema dimenzemi: i) True, False, ii) sl1, sl2, iii) nm1 az nm5 , , False sl1 sl2
nm1 nm2 nm3 nm4 nm5
11 12 13 14 15
11 12 13 14 15
, , True sl1 sl2 11 11 12 12 13 13 14 14 15 15
nm1 nm2 nm3 nm4 nm5
Seznam (list) je zvláštní objekt, který může obsahovat další objekty (čísla, vektory, matice, pole atd.). Seznamy mohou obsahovat názvy položek, ale i prázdné položky.
> list(one=c(1:3), two=c("A"), three=matrix(1:6, c(2,3))) # vytvoříme seznem sestavajici z ciselneho vektoru one, vektoru two, obsahujici jeden znak a matice s nazvem three $one [1] 1 2 3 $two [1] "A" $three [,1] [,2] [,3] [1,] 1 3 5 [2,] 2 4 6
Datová tabulka – dvourozměrná tabulka, u které všechny sloupce musí obsahovat stejný počet prvků. Každý sloupec může obsahovat jiný typ dat, ale ve stejném sloupci musí být stejný typ dat. Výhodou tabulky je, že do něj můžeme importovat data z běžně používaných datových zdrojů, tabulek.
> data.frame(sloupec1=c(1:5), sloupec2=rep("A", times=5)) sloupec1 sloupec2 1 1 A 2 2 A 3 3 A 4 4 A
5
5
A
Faktor (factor) můžeme popsat jako vektor nominálních nebo ordinálních znaků. Může obsahovat různé úrovně (levels), které je možné označovat.
> factor(rep(c("A","B"), times=5)) [1] A B A B A B A B A B Levels: A B > factor(c(1,2,2,3,3,3,4,4,5,5,5,5,5)) [1] 1 2 2 3 3 3 4 4 5 5 5 5 5 Levels: 1 2 3 4 5
Při zpracování dat je někdy potřeba konkrétní typ objektu převést na jiný typ. Postupy pro převod mohou být někdy více a někdy méně složité. Pro tyto postupy je vhodné nejprve objekt otestovat pomocí funkce is.typ_objektu() – například is.numeric() a poté převést na jiný typ pomocí as.typ_objektu(), například as.character(). V nápovědě jsou tyto metody převodu dostupné voláním methods(is) a methods(as). > y = "1"; y; class(y) # vytvoříme vektor s jednim znakem, vypiseme ho a zjistime vlastnost [1] "1" [1] "character" > is.numeric(y) # otestujeme zda je prvek vektoru číslo [1] FALSE > as.numeric(y); y; y=as.numeric(y); y; class(y) # prevedeme na číslo, zustava však znakem, prevedeme na číslo tak, ze ho priradime tomu istemu vektoru, vypiseme vlastnosti [1] 1 [1] "1" [1] 1 [1] "numeric"
Pro práci s objekty je někdy důležité vědět důležité informace o objektech, případně umět s objekty manipulovat. K tomu slouží různé funkce. Pro vypsání všech objektů v pracovním prostředí můžeme použít funkci ls() nebo objects(). Vymazat objekty můžeme pomocí funkce rm(). > rm(list=objects()); ls(); objects(); a="a"; ls(); objects() character(0) character(0)
[1] "a" [1] "a"
Vnitřní struktura objektu se vypíše použitím funkce str(). Objekty je možné i okomentovat, případně vypsat komentář k objektu, funkce comment(). Funkce attributes() umožňuje nastavovat vlastnosti objektů nebo tyto vlastnosti pouze vypíše. Podobná funkce, attr(), vypisuje vlastnosti objektu. Celkový přehled o daném objektu je možné získat pomocí summary (). > a="a"; b=3; str(a); str(b) chr "a" num 3 > tabulka=data.frame(sl1=c(1:5), sl2=c(6:10)); tabulka # vytvoříme tabulku, kterou nasledne testujeme (jeji strukturu, atributy atd., viz nize) sl1 sl2 1 1 6 2 2 7 3 3 8 4 4 9 5 5 10 > comment (tabulka); comment(tabulka, ) NULL > attributes(tabulka) $names [1] "sl1" "sl2" $row.names [1] 1 2 3 4 5 $class [1] "data.frame" > summary(tabulka) sl1 sl2 Min. :1 Min. : 6 1st Qu.:2 1st Qu.: 7 Median :3 Median : 8 Mean :3 Mean : 8 3rd Qu.:4 3rd Qu.: 9 Max. :5 Max. :10
V případech, kdy chceme pracovat s jednotlivými prvky objektu, které jsou nějak označeny, je možné použít funkce pro připojení attach() a odpojení detach() objektu. Jednotlivé prvky objektu používáme bez specifikace objektu. > attach(tabulka); sl1; sl2; detach(tabulka) # po pripojeni tabulky muzeme volat prvky sloupců tabulky nazvem sloupce [1] 1 2 3 4 5 [1] 6 7 8 9 10
Možnosti výpočtů a práce s operátory Při práci s objekty můžeme používat různé operátory (matematické, množinové, logické) a funkce a výsledky ukládat do stejných typů objektů. Mezi matematické operátory patří + sčítání, - odčítání, * násobení, / dělení, ^ umocňování, %/%, celočíselné dělení, %%zbytek po celočíselném dělení, sum() sčítání množiny čísel, prod() násobení množiny čísel, min() nejmenší hodnota, max() největší hodnota. Počet prvků jakéhokoliv objektu zjistíme pomocí funkce length(). > a=c(2); b=c(3); a+b; a-b; a*b; a/b; a^b; a%/%b; a%%b [1] 5 [1] -1 [1] 6 [1] 0.6666667 [1] 8 [1] 0 [1] 2 > a=c(1,2,3); b=c(1:5); sum(a); sum(b) [1] 6 [1] 15 > a=c(1,2,3); b=c(1:5); prod(a); prod(b) [1] 6 [1] 120
Mezi množinové operátory patří testování, zda je daná množina podmnožinou druhé pomocí %in%, průnik množin pomocí funkce intersect(), sjednocení množin pomocí union(), výčet prvků, které nejsou obsaženy v druhé množině prvků, pomocí funkce setdiff(). > a=c(1,2,3); b=c(1:5); a %in% b [1] TRUE TRUE TRUE > a=c(1,2,6); b=c(1:5); a %in% b
[1]
TRUE
TRUE FALSE
> a=c(1,2,6); b=c(1:5); union(a, b) [1] 1 2 6 3 4 5 > a=c(1,2,3); b=c(1:5); union(a, b) [1] 1 2 3 4 5 > a=c(1,2,3); b=c(1:5); intersect(a, b) [1] 1 2 3 > a=c(1,2,6); b=c(1:5); intersect(a, b) [1] 1 2
Je možné využívat logické operátory, mezi které patří rovno ==, není rovno !=, menší než <, větší než >, menší nebo rovno <=, větší nebo rovno >=, a zároveň &, nebo |, negace !. Výstupem testování pomocí logických nebo množinových operátorů jsou obvykle logické hodnoty TRUE nebo FALSE. > 1==2; 1==1; 1!=2; 1!=1 # zapis znamena 1 se rovná 2 (NEPRAVDA); 1 se rovná 1 (PRAVDA); 1 se nerovna 2 (PRAVDA); 1 se nerovna 1 (NEPRAVDA) [1] FALSE [1] TRUE [1] TRUE [1] FALSE > 1<2; 1>2; 1<=2; 1>=2 [1] TRUE [1] FALSE [1] TRUE [1] FALSE > 1==1 & 1<2; 1==1 & 1>2 [1] TRUE [1] FALSE > 1==1 | 1<2; 1==1 | 1>2 [1] TRUE [1] TRUE > 1==1 | 1<2; 1!=1 | 1>2 [1] TRUE [1] FALSE
> !1==1; !1<2; !1>2 [1] FALSE [1] FALSE [1] TRUE
K základním matematickým funkcím patří abs(), exp(), logb(), log(), log10(), sqrt(), sign(), trigonometrické a hyperbolické funkce sin(), cos(), tan(), sinh(), cosh(), tanh(), inverzní trigonometrické a inverzní funkce asin(), acos(), atan(), asinh(), acos(), atanh(). Faktoriál vypočteme pomocí funkce faktorial(). Pro počet kombinací bez opakování (n nad k) využijeme funkci choose(n, k). Funkce sample() vypočte kombinace čísel bez nebo s opakováním. > a=2; b=3; factorial(a); factorial(b) [1] 2 [1] 6 > a=2; b=3; choose(a, b); choose(b, a) [1] 0 [1] 3 > sample(1:5, size=5, replace=T) [1] 4 2 2 1 4 > sample(1:5, size=5, replace=F) [1] 3 5 1 4 2
Při práci s čísly je možné použít funkce zaokrouhlování, jako zaokrouhlení na určitý počet desetinných míst round(), vrácení celé části daného čísla trunc(), zaokrouhlení na nižší floor() nebo vyšší ceiling() celé číslo, zaokrouhlení čísla na určitý počet platných číslic signif(). > a=c(2); b=c(3); round(a/b, digits=1); round(a/b, digits=3) [1] 0.7 [1] 0.667 > a=c(2); b=c(3); trunc(a/b); trunc(b/a) [1] 0 [1] 1 > a=c(1.111, 2.222, 3.333); floor(a); ceiling(a) [1] 1 2 3 [1] 2 3 4
> a=c(111.11, 22.22, 3.333); signif(a, digits=2); signif(a, digits=3) [1] 110.0 22.0 3.3 [1] 111.00 22.20 3.33
Generování pseudonáhodných čísel je možné pomocí mnoha funkcí, a to v závislosti na rozdělení (pravděpodobnostní funkce), které nás zajímá. Například pro generování čísel z uniformního rozdělení použijeme funkci runif(), a pro generování čísel z normálního rozdělení funkci rnorm(). > runif(5, min=1, max=5) [1] 4.267991 3.974507 1.711294 1.659437 2.794028 > x=runif(5, min=1, max=5); trunc(x) [1] 4 1 2 2 1 > rnorm(5, mean=0, sd=1) [1] 0.23728890 -0.01456454 -1.74993824 -0.57132708 0.33852893
Mezi konstanty, které jsou součástí základní instalace, patří například letters, LETTERS, month.name. a pi. > letters; LETTERS [1] "a" "b" "c" "d" "e" "n" "o" "p" "q" "r" "s" [20] "t" "u" "v" "w" "x" [1] "A" "B" "C" "D" "E" "N" "O" "P" "Q" "R" "S" [20] "T" "U" "V" "W" "X"
"f" "g" "h" "i" "j" "k" "l" "m" "y" "z" "F" "G" "H" "I" "J" "K" "L" "M" "Y" "Z"
> month.name [1] "January" "February" "June" [7] "July" "August" "November" "December"
"March"
"April"
"May"
"September" "October"
> pi [1] 3.141593
Mezi vybrané funkce popisné statistiky patří funkce mean() – průměr, median() – median, min() – minimální hodnota, max() – maximální hodnota, sd() – standardní odchylka, fivenum() a summary() – shrnutí základních parametrů souboru dat pomocí popisné statistiky.
Načtení a zápis dat na disk Data je možné vytvořit přímo v programu R jejich přirazením ke konkrétnímu objektu. Načtení můžeme provést také ze schránky nebo ze souboru. Protože při zpracovávání dat jsou data již vytvořena, pro načtení dat můžeme použít několik funkcí. Funkce scan () umožňuje načíst data ze souboru nebo ze schránky do vektoru. Data jsou ve formě character. Funkce read.table() čte data podobně jako funkce scan(). Načtení však probíhá do tabulky dat označovanou taky data.frame. Pomocí funkce edit() otevřeme objekt v editoru dat a můžeme data upravovat. Je možné je vytisknout na obrazovku nebo je uložit do objektu. Pro úpravu dat v editoru můžeme použit funkci fix (). > # nacteme text v tomto komentari pomoci funkce readClipboard() > readClipboard() [1] "# nacteme text v tomto komentari pomoci funkce readClipboard()"
# práce s ctenim a zapisem dat na disk do pracovního adresare > tabulka=data.frame(sl1=c(1:5), sl2=c(6:10)) # vytvoříme tabulku > tabulka # vypiseme tabulku sl1 sl2 1 1 6 2 2 7 3 3 8 4 4 9 5 5 10 > write.table(tabulka, file="tabulka.txt") # uložíme tabulku na disk, nespecifikujeme oddelovac
> write.table(tabulka, file="tabulka.txt", sep=";") # uložíme tabulku na disk a specifikujeme oddelovac jako strednik ;
> tabulka2=read.table("tabulka.txt", header=TRUE, sep=";") # nacteme tabulku se separátorem strednik > tabulka2 # vypiseme načtenou tabulku sl1 sl2 1 1 6 2 2 7 3 3 8 4 4 9 5 5 10 > tabulka2=edit(tabulka2) # tabulku muzeme editovat a zmeny se nam ulozi znovu do tabulky2
> tabulka2 # vypiseme upravenou tabulku sl1 sl2 1 1 6 2 1000 7 3 3 8 4 4 9 5 5 10
Manipulace s objekty a jejich prvky Pro výpis a filtrování určitých prvků konkrétního objektu používáme hranaté závorky *+. Nastavením argumentu drop=F můžeme objekt zjednodušit. Pomocí znaku dolar $ je možné vypisovat sloupce tabulky nebo seznamu. Ty však musí být pojmenovány. Přidávat hodnoty k vektoru nebo tabulce je možné pomocí funkce append(). Slučování vektorů, matic tabulek je možné pomocí cbind() – po sloupcích, rbind() – po řádcích. Velikost objektu můžeme zjistit funkcí length(). Vzestupné nebo sestupné seřazení hodnot získáme příkazem sort(). Pořadí hodnot v dané řadě je možné získat funkcí rank() a převrácené pořadí hodnot funkcí rev(). Nahrazení hodnot na určitém místě je možné pomocí replace(). duplicated() vyhodnotí, zda se hodnota položky opakuje nebo je čtena poprvé. unique() vypíše objekt bez duplikátů. Počet sloupců a počet řádů matice nebo tabulky je možné získat funkcemi ncol() a nrow(). Počet dimenzí objektu je možno vypsat pomocí dim() a jména dimenzí pomocí dimnames(). subset() vybere z objektu pouze zadané položky. Pro práci s maticí (matrix) a polem (array) je možné využít funkce t() pro transponování matice, det() pro výpočet determinantu matice, diag() pro vypsání nebo vytvoření diagonály matice, %*% umožňuje násobení matic. Případné vypsání nebo nastavení jmen řádků a sloupců je možné pomocí funkcí rownames(), colnames().
U objektů programu, které obsahují položky tags (popisky), jako jsou například seznamy (list) nebo tabulky (data.frames) je možné vypsat nebo změnit jejich názvy (názvy jednotlivých seznamů, názvy sloupců tabulky) pomocí funkce names(). Pomocí funkce factor() můžeme z vektoru vytvořit objekt typu faktor, který obsahuje nominální proměnné. Funkcí levels() vypíšeme nebo nastavíme hodnoty objektu faktor. Velmi důležité jsou funkce pro práci se znaky a řetězci. paste() sloučí vektory do řetězců a může je oddělit separátorem specifikovaným pomocí argumentu sep. tolower(), toupper() převede řetězec na malá nebo velká písmena. chartr() nahradí v řetězci staré znaky novými. noquote() vynechá mezery při vypisování řetězce. nchar() vrátí počet znaků řetězce. strsplit() rozdělí řetězec podle zadaného vzoru. Mezi další funkce k provádění hromadných výpočtů jednotlivých prvků objektů patří rowsum(), rowSums(), colSums(), rowMeans(), colMeans(), které vypočítají sumu a průměrné hodnoty v řádcích nebo ve sloupcích objektu. Pomocí tabulate() spočítáme četnosti celých kladných a záporných hodnot vektoru. Funkce table() spočítá četnosti faktoru a je důležitá při tvorbě kontingenčních tabulek. Funkce apply() vypočte funkci pro každý řádek nebo dimenzi objektu. Pomocí lapply() a sapply() provádíme výpočet konkrétní funkce v jednotlivých položkách seznamu. Funkce tapply() umožňuje aplikaci funkce na roztříděná data v tabulce dat. Funkce by() podobně jako tapply() rozdělí data podle vektoru a pro každou skupinu vypočítá zadanou funkci. Slučování položek v tabulce lze provést pomocí funkce aggregate(). Položky jsou slučovány podle seznamu v argumentu funkce a sloučení se provede dle nastavené funkce.
Vytváření vlastních funkcí, používání cyklů a podmíněných výrazů Protože program R je i programovacím jazykem, máme kromě funkcí, které jsou součástí jednotlivých balíčků také možnost vytvářet vlastní funkce. Pomocí vlastních funkcí můžeme vytvářet vlastní postupy při analýze dat. Jak již bylo zmíněno, každá funkce má soubor argumentů a příkazy pro práci s objekty. Novou funkci je možno vytvořit pomocí function(). Do závorek uvedeme proměnné, se kterými se bude pracovat. Příkazy, které se mají vykonat, se zapíšou do složených závorek ,-. # vytvorime funkci pro vypocet smerodatne odchylky > std = function(x) { + sqrt(var(x)) + }
# vektor, ze ktereho se smerodatna odchylka vypocita > a = c(1,3,5,2,3,2,4,6,8,10,5) > std(a) # nase funkce [1] 2.733629 > sd(a) # vypocet srovnáme s funkci pro vypocet smerodatne odchylky [1] 2.733629
Kromě definování vlastních funkcí můžeme pro ulehčení zpracování dat používat cykly s daným počtem opakování a podmíněné výrazy. Obecně lze podmíněný výraz zapsat if (podmínka) {prikaz_1} else {prikaz_3} nebo if (podminka) {prikaz_2; prikaz_3} else {prikaz_4; prikaz_5 }. V podmínkách je možné používat logické operátory. > if (1 == 1) {print("pravda")} else {print("nepravda")} [1] "pravda" > if (1 == 2) {print("pravda")} else {print("nepravda")} [1] "nepravda"
Opakovací cykly vytváříme pomocí for, repeat a while. Pro for můžeme zapsat obecný výraz for (jmeno_promenne in ciselny_vektor) {prikazy}. Číselný vektor má často tvar například 1:10. Příkazy se mohou uvádět do složených závorek, podobně jako při podmíněných výrazech. K dalším opakovacím cyklům patří repeat ,příkaz- a while (podmínka) ,příkaz-. > for (i in 1:5) {print("1 az 5")} [1] "1 az 5" [1] "1 az 5" [1] "1 az 5" [1] "1 az 5" [1] "1 az 5"
Základy grafiky I vzhledem k jinému způsobu zpracováváni dat v programu R, ve srovnání s jinými programy, jsou grafické výstupy srovnatelné s jinými komerčně dostupnými programy. Velkou výhodou je právě možnost zpracování dat prostřednictvím velkého množství grafických funkcí a jejich vlastností (nastavitelné pomocí argumentů funkce). Obecně je možné v oblasti grafiky pracovat s klasickým základním prostředím programu, použít tzv. Grid systém s vlastními funkcemi nebo použít jiné balíčky, například lattice (grafy typu Trellis).
V tomto textu se budeme věnovat pouze základnímu klasickému prostředí, které umožňuje pracovat ve třech úrovních. Patří mezi ně high-level, low-level funkce a možnost interaktivní grafiky. High-level funkce umožňují tvorbu jednoduchých grafů, které mají předdefinované vlastnosti. Low-level funkce umožňují více nastavení pro jednotlivé prvky grafů. Umožňují také nastavování přesných rozměrů grafů, vpisování a vykreslování různých objektů apod. Interaktivní grafika umožňuje pracovat s polohou kurzoru v grafu a její výhodou je možnost přidávat data do grafu nebo je extrahovat. Mezi důležité funkce interaktivní grafiky patří locator() – čte nastavení kurzoru a identify () – identifikuje nejblíže vykreslený bod od pozice kurzoru. Kromě základních grafických úrovní existuje řada balíčků, které obsahují specifické grafy. Program R je proto velmi dobrým programem pro přípravu grafických výstupu zpracovaných dat pro jakékoliv další využití. K základním high-level grafům patří:
grafy jedné a dvou proměnných – plot() - bodový graf, barplot() – sloupcový, hist() – histogram, boxplot() – krabicový graf, pie() – koláčový graf grafy tří proměnných – persp(), contour(), filled.contour(), image(), symbols() – bublinový graf grafy s více než třemi proměnnými, kde je možné využít například funkce pairs() – grafy, kde srovnáváme každou proměnnou se všemi dalšími (vytvoří se maticie bodových grafů), stars() - hvězdicové grafy pro kontinuální proměnné, mosaicplot() - mozaikový graf kategoriálních dat z moderních specializovaných typů grafů možno jmenovat dotchart(), dotplot(), sunflowerplot() – bodový graf s opakujícími se daty (vznikají květiny), hexbin() – nutnost využití balíčku hexbin, contour(), image(), jitter(), assocplot() – pro kategoriální data, více možností je v balíčku vcd, plot() – vytváří dendrogramy – více možností je dostupných v balíčcích rpart, maptree.
Jednotlivé prvky grafu a samotné symboly v diagramech se vykreslují voláním low-level funkcí. Mezi ně patří axis (osy), grid (mřížka), legend (legendy), rug (kartáč), title (nadpis a podnadpis), text (textové pole), points (body), lines (čáry), segments (úsečky), abline (přímky), mtext (text na okraji grafu), matpoints (body v samostatných řadách), matlines (spojnice ve více řadách), curve (křivky), box (obrys – obdélník kolem grafu), symbols (kružnice, obdélníky apod.), rect (obdélnik), polygon (mnohouhelník), arrows (šipky).
Grafy se vykreslují v grafických zařízeních (grafických oknech). Pro práci s nimi existuje také několik funkcí. Tyto funkce umožňují jak nastavení vlastností grafického výstupu, tak samotného grafu. Patří mezi ně windows() – otevření a nastavení grafického okna, windows(), dev.list() – seznam zařízení, dev.cur() – zjištění, dev.set() – nastavení aktuálního zařízení, dev.off() – vypnutí (zavření) zařízení, graphics.off() – vypne všechna zařízení. Dále to jsou split.screen() – rozdělí okno, erase.screen() – vymaže obsah okna, close.screen() – zavře okno, layout() – nastaví rozdělení okna, podobně jako split.screen(), plot.window() – nastavení koordinát okna, plot new() a frame() – vytvoří grafické okno. Důležitou funkcí je funkce par(), která umožňuje nastavit velmi velké množství vlastností grafického výstupu v okně (vlastnosti samotného grafu). K dalším funkcím, které se využívají pro nastavení grafiky, patří rgb() – namíchání barvy, colors () – přednastavení barvy, palety barvy (palette(), rainbow(), hcl(), terrain.colors() atd.), recordPlot() – uložení grafu jako proměnné, savePlot() – uložení grafu atd. Při práci s grafikou je důležité rozeznávat jednotlivé části grafického zařízení a grafu samotného. Detaily na obrázku. Grafické zařízení je rozděleno na oblast vnějšího okraje a oblast vykreslené grafiky, jejíž součástí je oblast samotného grafu. Jak je vidět na dalším obrázku, oblast pro vykreslování grafiky může být rozdělena na několik částí, do kterých se grafické prvky (grafy) vykreslují.
Do grafického zařízení se tedy vykreslují obrázky (figures), které mohou mít vnější okraj (outer margin) a oblast s grafem (plot region).
I oblast pro vykreslování obrázku má vnější okraj (figure margin) a oblast grafu (plot), jak je znázorněno na dalším obrázku.
Všechny hodnoty okrajů jsou nastavitelné.
Základní grafika Základní grafy je tedy možné vytvářet pomocí high-level funkcí. Pro pokročilejśí grafické výstupy je možné kombinovat high-level funkce s low-level funkcemi. Při použití high-level funkcí jsou základní nastavení grafu určeny pomocí argumentů funkcí. Jejich množství je omezeno, a proto se v případě potřeby před voláním high-level funkce volá funkce par(), která nastavuje parametry grafického výstupu. Kombinací high-level funkce a funkce par() můžeme dosáhnout požadované nastavení jednotlivých prvků grafu. Pro názornost a pochopení jak jednotlivé parametry funkce par() zobrazují data, je vhodné vytvořit několik sérií grafů s různým nastavením argumentů funkce par(). V následující části budou stručně popsány základní parametry vybraných funkcí. Důležité pro zapamatování není jejich přesný výčet a popis, ale schopnost práce s nápovědou, ve které můžeme dohledat veškeré podrobnosti k dané funkci a určit tak potřebné nastavení žádaných parametrů výstupu. Pro zobrazení nápovědy u každé funkce stačí zadat příkaz, například ?par().
Funkce par() – nastavení textových částí grafu
adj – číslo. Určuje, jak je zarovnaný textový řetězec. Hodnoty 0 – zleva, 0.5 – uprostřed, 1 – vpravo. Povoleny jsou všechny hodnoty z intervalu [0, 1]. Funkce text má povoleno zadat vektor adj = c(x, y), který určuje zarovnání jak ve směru horizontálním, tak i ve směru vertikálním. ann – logická hodnota. Vypisuje anotace jako název a podnázev grafu a popisky os. cex – číslo. Určuje relativní velikost znaků, kde 1 – normální velikost, 2 – dvojnásobná velikost. cex.main, cex.sub – číslo. Určuje relativní velikost znaků pro nadpis grafu a podnadpis. col.main, col.sub – řetězec nebo číslo. Určuje barvu pro název a podnadpis grafu. cra – pouze čtení; velikost aktuálních znaků (šířka, výška) v rastru (pixelech). crt – číslo. Udává rotaci jednotlivých znaků ve stupních. family – řetězec. Určuje typ písma "serif", "sans", "mono", "symbol". font – číslo. Určuje řez písma pro text. Možné hodnoty jsou 1 (normální), 2 (tučné), 3 (kurzíva), 4 (tučná kurzíva). font.main, font.sub – číslo. Určuje řez písma názvu a podnázvu grafu. lheight – výška řádku textu, standardně 1, nastavené hodnoty jsou násobky. ps – číslo. Určuje velikost textu a symbolů (jednotky jsou pixely – body). srt – číslo. Určuje rotaci řetězců v úhlech. Podobně jako crt.
Funkce par() – nastavení grafických částí grafu
bg – určuje barvu pozadí grafu a pro body také barvu jejich výplně gamma – číslo. Specifikuje gamma korekci. bty – řetězec. Umožňuje zvolit typ ohraničení kolem grafu. Možné hodnoty jsou "o" – kolem celého grafu, "l" – levý a dolní oraj, "7" – pravý a horní okraj, "c" – horní, dolní, levý okraj, "u" – levý, pravý, dolní okraj, "]" - dolní, horní, pravý okraj, "n" – okraje se nevykreslí. fig – číselný vektor. Nastavuje oblast vykreslení grafické oblasti v daném grafickém okně pomocí normalizovaných koordinát. Má tvar c(x1, x2, y1, y2). mar – číselný vektor. Nastavuje počet řádků kolem grafu v obrázku grafického okna. Má tvar c(dole,vlevo,nahoře,dole).
mfcol, mfrow – číselný vektor. Rozděluje grafické okno na obrázky. Vektor znamená c(počet_řádků, počet_sloupců). Mfcol vypisuje po sloupcích, mfrow po řádcích. mfg – číselný vektor. Určuje, který z obrázků se bude vykreslovat nebo vykresluje. usr – číselný vektor. Nastavuje extrémy koordinát vykreslované oblasti grafu a má tvar c(x1,x2,y1,y2). oma – číselný vektor. Udává velikost vnějších textových okrajů nebo okrajů v oknech s více grafy. Má tvar c(dolní,levý,horní,pravý). omi – vektor c(dolní,levý,horní,pravý). Udává velikost vnějších okrajů v palcích pin – číselný vektor. Udává šířku a výšku aktuálního grafu v palcích. plt – číselný vektor. Má tvar c(x1, x2, y1, y2) a udává souřadnice grafu jako proporce k celkové oblasti obrázku. pty – řetězec. Udává typ grafické oblasti, která může být "s" (čtvercová) nebo "m" (maximální). xpd – logická hodnota nebo NA. Určuje oblast pro vykreslování. Hodnota FALSE – vykreslování je vztaženo pouze na grafickou oblast a hodnota TRUE – vykreslování je vztaženo na celou oblast grafického zařízení. Lze kreslit i mimo plochu grafu.
Funkce par() – nastavení os grafu
cex.axis, cex.lab – nastaví velikost písma pro popisky a pro názvy os. col.axis, col.lab – určuje barvu pro popisky a pro názvy os. fg – určuje barvu pro osy a ohraničení grafu. font.axis, font.lab – číslo. Určuje řez písma pro popisky a názvy os. las – číslo. Určuje otočení popisků na osách. Možné hodnoty jsou 0 – znamená y svisle a x vodorovně, 1 – x a y vodorovně, 2 – x svisle a y vodorovně, 3 – x a y svisle. lab – numerický vektor tvaru c(x, y, len). Určuje přibližné počty značek osy x a y. tck – číslo. Nastaví velikost značek na osách jako proporce šířky nebo výšky grafické oblasti. Hodnota 1 vykreslí mřížku. tcl – číslo. Nastaví výšku značek na osách jako proporce velikosti řádku textu. xaxp, yaxp – číselný vektor. Má tvar c(x1, x2, n). Určuje min a max pro značku na ose a počet intervalů mezi značkami. xaxs, yaxs – řetězec. Určuje, zda se osy odsadí od okraje, hodnota "r" (odsazení dat o 4 %) a hodnota "i" znamená přesné nasazení k ohraničení.
xaxt, yaxt – řetězec. Určuje typ osy. Možné hodnoty jsou "n" jako nastavena, ale nezobrazena. Hodnoty "s", "l", "e" osy zobrazují. xlog, ylog – logická hodnota. Udává, zda se osy vykreslí v logaritmickém měřítku. Možné hodnoty jsou TRUE, FALSE.
Funkce par() – nastavení jednotlivých řad grafu
col – číslo nebo řetězec. Určuje barvu bodů nebo jejich ohraničení. lend – číslo nebo řetězec. Určuje ukončení čáry. Možné hodnoty jsou 0 nebo "round", 1 nebo "butt", 2 nebo "square". ljoin – číslo nebo řetězec. Určuje hranu spoje dvou čar. Možné hodnoty jsou 0 nebo “round“, 1 nebo "mitre", 2 nebo "bevel". lmitre – určuje limit zkosení při spojování čar od 1 standardně 10. lty – určuje typ čáry, viz plot. lwd – Určuje šířku čáry, standardně se čára vykresluje s hodnotou 1. pch – Určuje znaky pro vykreslování bodů grafu.
Funkce plot() vytváří grafy různých typů a to dle formátu vstupních dat a nastavení vybraných argumentů funkce. Graf je možno vytvořit z jednoho, případně dvou vektorů (hodnoty x a y). Například v případě, že vektor je faktorem, vykreslí se sloupcový graf, funkce se vykreslí jako křivka, nutno zadat obor hodnot (limity na ose x).
type – typ vykreslení diagramu ("p" bodový, "l" liniový, "h" vertikální linie, "o" linie s body, "n" nevynášet, "b" přerušované linie s body, "c" přerušované linie bez bodů, "s" schodovité s první linií horizontální, "S" schodovité s první linií vertikální), zápis jako řetězec v uvozovkách xlim, ylim – určuje rozsah x-ové a y-ové osy, zápis jako vektor se dvěma prvky (například c(0,10) log – určí, která osa má být logaritmicky transformována, zapisuje se řetězec v uvozovkách ("x", "y" nebo "xy") main, sub xlab, ylab – název grafu, podnázev, název osy x a y, zápis jako textový řetězec v uvozovkách plot, ann, axes, frame.plot – určuje, zda se vykreslí graf, názvy os a grafu, osy samotné, ohraničení grafu, zadává se jako logická hodnota bez uvozovek (například TRUE, T, FALSE, F) col – určuje barvu bodů, jejich obrysy nebo spojnice, možno zadat jako vektor nebo textový řetězec do uvozovek (název barvy, například „green“) pch – určuje typ vykreslených bodů, Vektor, číslo od 0 do 25 bg – určuje barvu pozadí dvoubarevných bodů, které se vykreslují parametrem pch
cex – určuje relativní velikost znaků a bodů oproti standardním lty, lwd – určuje typ čáry a tloušťku čáry asp – určuje poměr osy y/x. asp = 1 poměr osy x a y bude zachován.
Pro grafický výstup nahoře je uveden pracovní skript, viz níže. x=c(1,2,3,4,5); y=c(2,4,6,8,10); tpe=c("p", "l", "h", "o", "n", "b", "c", "s", "S") par(mfrow=c(3,3), mar=c(2,2,1,1)) for (i in 1:9) { plot(x,y,type=tpe[i]) }
Pro grafický výstup nahoře je uveden pracovní skript, viz níže. x=c(1,2,3,4,5); y=c(2,4,6,8,10) par(mfrow=c(5,5), mar=c(2,2,1,1)) for (i in 1:25) { plot(x,y,type="p", pch=i) }
Pro grafický výstup nahoře je uveden pracovní skript, viz níže. x=c(1,2,3,4,5); y=c(2,4,6,8,10) par(mfrow=c(5,5), mar=c(2,2,1,1)) for (i in 0:24) { plot(x,y,type="p", col=i) }
Barplot() je funkce pro vytváření sloupcových grafů.
height – vektor nebo matice beside – vykreslení více řad vedle sebe (TRUE) nebo nad sebou (FALSE). Data musí být v matici. Řady tvoří řádky matice. width – číselný vektor. Udává šířku sloupců. space – číselný vektor nebo číslo. Udává velikost mezery mezi sloupci. Také velikost mezer mezi sloupci jednotlivých řad u maticových dat. Podmínkou je nastavení hodnoty beside=T a vektor má dvě hodnoty, například c(1,2). names.arg – vektor. Udává názvy sloupců, které se vynáší na osu x. legend.text – textový vektor. Pro více datových řad uvádí názvy v legendě. horiz – logická hodnota. Nastavuje horizontální nebo vertikální vykreslování sloupců. density – vektor nebo číslo. Nastavuje šířku šrafování sloupců. angle – číslo nebo vektor. Nastavuje sklon šrafování sloupců.
col – nastavuje barvu šrafování nebo barvu sloupců. border – nastavuje barvy hran sloupců. main, sub, xlab, ylab, xlim, ylim, cex.axis, cex.names – Stejné vlastnosti jako u předchozích funkcí par () nebo plot (). xpd – je dovoleno sloupcům přesahovat oblast grafu? axes, axisnames – logická hodnota. Vykresluje osy a jejich názvy. inside – logická hodnota. Vykresluje čáry mezi sloupci. plot – logická hodnoty. Určuje, zda se graf vykreslí nebo ne. offset – vektor. Určuje relativní posunutí grafu na ose add – logická hodnota. Určuje, zda se sloupce mají vykreslit do již vytvořeného grafu
Boxplot() je funkce pro vytváření krabicových grafů. Krabice tvoří medián, horní a dolní kvartil a 1,5x mezikvartilové rozpětí (hodnoty mimo jsou vynášeny jako odlehlé). Tato funkce obsahuje i statistické výstupy: stats (horní a dolní ohraničení, ohraničení krabic a medián), n (počet pozorování), conf (konfidenční intervaly), out (odlehlé hodnoty), group (skupiny, do které patří odlehlé hodnoty), names (názvy skupin).
formula – vzorec. Závislá proměnná ~ nezávislá proměnná. Možno zadávat i sloupce tabulek dat jako číselný vektor. data – proměnná obsahující data. range – číslo. Násobí IQR (mezikvartilové) rozpětí a udává rozmezí spodního a horního limitu. Standardně je nastaveno na hodnotu 1.5. Hodnota 0 udává rozpětí až po extrémy dat. width – číslo. Udává relativní velikost krabic ve vzájemném poměru. varwidth – proporční velikost krabic vzhledem k odmocnině počtu dat v každé ze skupin. notch – logická hodnota. Zobrazuje výřezy počítané jako ±1.58*IQR/sqrt(n), kde n je počet pozorování. Jestliže se výřezy dvou krabic nepřekrývají, lze dost průkazně odhadovat, že se mediány liší. outline – logická hodnota. Udává, zda se mají zobrazovat odlehlé hodnoty. names – textový vektor. Nastavuje názvy jednotlivých krabic zobrazovaných na ose x. horizontal – logická hodnota. Vykresluje krabice horizontálně. at – číselný vektor. Udává, kde se vykreslí krabice. border, col, log, plot, add – podobně jako u předchozích grafů pars – možnost úpravy dalších grafických parametrů pomocí seznamu, který může obsahovat další argumenty jako například boxwex pro
změnu velikosti krabic, boxlty, boxlwd, boxcol, boxfill pro nastavení typu čáry, šířky, barvy a výplně krabic apod. Stem() je funkce pro vytváření grafu stonek a lodyha. Graficky znázorňuje četnosti hodnot. Vyhodnocuje numerický vektor.
scale – číslo. Určuje stupeň škálování. atom – číslo. Určuje toleranci rozlišování hodnot. width – číslo. Určuje šířku grafu.
Stripchart() je funkce pro jednoduché zobrazení dat. Zobrazuje jejich rozptýlení.
method – určuje zorazení dat na ose, náhodně kolem osy nebo naskládány na sobě, hodnoty "overplot", "jitter" a "stack" jitter – číslo. Určuje rozsah rozložení kolem osy. offset – číslo. Nastavuje rozestup při metodě "stack". vertical – logická hodnota. Umožňuje vykreslovat vertikálně. group.names – textový vektor. Nastavuje názvy skupin, které se mají vykreslovat po bocích grafu. add, at – logická hodnota, číselný vektor. Podobně jako u jiných typu grafů.
Pie() je funkce pro koláčový graf. Data jsou uložena ve vektoru.
labels – textový vektor. Označuje popisky u grafu. edges – číslo. Nastavuje počet stran mnohoúhelníku, který se vykreslí místo kružnice. radius – číslo s hodnotami [-1,1]. Nastavuje velikost grafu. Záporná čísla vykreslí graf převrácený. density, angle – číslo. Určuje hustotu a úhel (ve stupních) šrafování jednotlivých dílů koláče. clockwise – logická hodnota. Nastavuje vykreslování grafu ve směru nebo proti směru hodinových ručiček. init.angle – počáteční úhel (natočení grafu) col – číselný nebo textový vektor. Nastavuje barvy šrafování nebo výplně jednotlivých dílů grafu. border, lty – vektory určující barvy a typy čár tvořící okraje jednotlivých dílů.
Hist() je funkce pro vytváření histogramů. Data jsou uložena ve vektoru. Tato funkce obsahuje i výstupy: breaks (hranice intervalů), counts (četnosti pro jednotlivé intervaly), density a intensity (hustota pravděpodobnosti pro
jednotlivé intervaly), mids (středy intervalů), xname (název objektu, ze kterého se histogram vytvořil), equidist (logická hodnota pro posouzení shody velikosti intervalů).
breaks – textový vektor. Nastavuje intervaly četnosti několika způsoby: o typ vytváření – zadán algoritmus vytváření intervalů "Sturges", "Scott", "FD" o počet tříd četnosti – počet tříd, číslo, udávající přibližný počet tříd o interval tříd četnosti – vektor, udávající hranice intervalů o funkce – funkce pro výpočet počtu tříd freq – logická hodnota. Určuje, zda se bude jednat o absolutní TRUE nebo relativní četnost FALSE. include.lowest – logická hodnota. Určuje, zda se do nejnižšího intervalu zahrne hodnota minima. V případě TRUE se u celých čísel zahrne první i druhá hodnota. right – logická hodnota. Intervaly uzavřené zprava, zleva otevřené v případě TRUE. angle, col, border, main, a další parametry jsou shodné s argumenty předchozích grafických funkcí.
Matplot() je funkce pro vynášení více řad do jednoho grafu bez použití lowlevel funkcí. Vynáší hodnoty vektorů nebo matic. Jinak jsou argumenty podobné funkci plot(). U matic jsou hodnoty x a y načteny z prvního a druhého sloupce matice. Funkci matplot() jsou podobné i funkce matpoints() – vynáší body a matline() – vynáší do grafu křivky s tím rozdílem, že data se přidávají do již vytvořeného grafu.
Pokročilejší grafika Jak již bylo uvedeno, pokročilejší vytváření a formátování grafu je možné dosáhnout kombinací funkcí pro nastavení a manipulaci s grafickými okny (zařízení) a low-level funkcí. Případně je možné doplňovat high-level funkce low-level funkcemi. Výhodou pokročilejší grafiky jsou možnosti doplnění grafických vlastností do grafu dle specifických požadavků a možnosti vytváření grafických výstupů krok po kroku. Při postupném vytváření grafiky pomocí low-level funkcí je dobré seznámit se i s funkcemi pro manipulaci s grafickými okny. Existuje celá řada předdefinovaných funkcí, mezi které patří zejména:
windows() – umožňuje otevřít grafické okno a nastavit jeho vlastnosti jako je velikost okna, písmo apod. K tomu je možné využívat parametry width, height (šířka a výška okna v palcích) , pointsize (velikost písma v bodech velikost 1/72 palce), xpinch, ypinch (počet bodů na palec), bg a canvas (nastaví barvu pozadí a plátna – pozadí a popředí), xpos, ypos (nastaví pozici grafického okna na obrazovce) dev.cur(), dev.list(), dev.off(), graphics.off() – umožňují nastavit nebo zjistit aktuální grafické okno, vypsat seznam grafických oken a zavřít grafická okna. plot.new () a frame() – vytvářejí nový graf v grafickém okně nebo přeskakují mezi více grafy v grafickém okně plot.window () – nastavuje vlastnosti grafu jako jsou limity obou os (xlim, ylim) a umožňuje vykreslit do grafu více os s jiným měřítkem. Další argumenty jsou podobné funkci par(). split.screen() – umožňuje rozdělit okno na řádky a sloupce podobně jako argumenty mfcol a mfrow u funkce par() recordPlot() – umožňuje nahrát aktuální graf jako objekt a později ho i vykreslit pomocí replayPlot(). savePlot() – umožňuje ukládat grafy v známých formátech pomocí argumentu type = c("wmf", "emf", "png", "jpg", "jpeg", "bmp", "tif", "tiff", "ps", "eps", "pdf")
Použitím nahoře uvedených funkcí musíme při vytváření grafu pokračovat funkcemi kategorie low-level. Pomocí nich je možné vytvářet jak části grafu (osy, názvy grafu, legendy,…), tak různé grafické prvky (body, přímky, úsečky atd.). Low-end funkce umožnují velmi efektivně dokreslovat grafické objekty do již vytvořených grafů. Low-level funkcí je velké množství, a proto uvádím pouze vybrané:
points(x,y,…) vykresluje body se souřadnicemi x a y. lines(x,y,…) vykresluje úsečky (čáry) mezi zadanými body x a y. segments(x0,y0, x0,y0,…) vykresluje úsečky mezi bodem X a Y dle souřadnic X*x0,y0+ a Y*x1,y1+. curve() vykresluje funkci dle zadané funkce. rect() vykresluje obdélník podle zadaných souřadnic. polygon() vykresluje mnohoúhelníky s vrcholy v bodech x,y (vektory). arrows() vykresluje šipky dle zadaných souřadnic. Lze s jejich pomocí kreslit například chybové úsečky. abline() vykresluje přímky horizontální a vertikální. text() vykreslí zadaný text dle zadaných souřadnic.
mtext() vykreslí text do okraje grafů, dle zadané linky pomocí argumentu line. symbols() vykresluje grafické prvky jako jsou kružnice, čtverce, obdélníky, hvězdy, symboly teploměru nebo krabicové grafy dle zadaných souřadnic. rug() umožňuje vykreslovat čárky na okraji os. Ulehčuje zobrazit rozložení dat, podobně jako funkce stripchart(). axis() vykresluje osy s možností nastavení značek a popisků značek osy. title() vykresluje název nebo podnázev grafu. grid() vykresluje mřížku grafu. legend() vykresluje legendu grafu, dle zadaných souřadnic.
Zajímavou možností je práce s interaktivní grafikou, u které jsou používány funkce identify() a locator(). Funkce identify() umožňuje po kliknutí do grafického okna určit, ke kterým souřadnicím je kurzor nejblíže. K těmto souřadnicím vykreslí popisky. Funkce locator() umožňuje určit přesnou polohu kurzoru po kliknutí do grafického okna. Tuto polohu je možné uložit do vektorového objektu a dále s ní pracovat.
Vybrané možnosti zpracováni dat pomocí programu R Grafické vyhodnocení dotazníku Následující příklad nám poslouží k tomu, abychom si vytvořili představu o tom, jak jednoduše můžeme graficky vyhodnotit dotazníky uzavřeného typu. Vyhodnocovaný dotazník byl vytvořen pomocí volně dostupné webové aplikace ZOHO Creator, ze které byla data exportována do CSV formátu a znovu uložena do formátu TXT. První část kódu nás navede na úpravu uložených (sesbíraných) dat z tabulky. Na obrázku dole je znázorněn obrázek s jednotlivými úpravami.
### -- Ukážeme si postup vytvoření grafického zpracovani uzavřených odpovědí v dotazníku. Použijeme k tomu první sloupec exportovaných dat. ### -- Odstraníme všechny objekty programu a nastavíme pracovní adresář a zjistíme, zda je správně nastaven rm(list=objects()) setwd("C:/Users/admin/Desktop/r")
getwd() ### -- Načteme a upravíme data. mydat=read.csv("Uvodni_dotaznik.txt", sep = "\t", header = TRUE, as.is = TRUE) ### -- Přejmenujeme název prvního sloupce. colnames(mydat)=c("Zajímá mě oblast IT a čtu informace ze světa IT?") ### -- Vypíšeme první sloupec a zjistíme jeho vlastnosti. mydat[1] class(table(mydat[1])) factor(table(mydat[1])) ### -- Postupně vytváříme grafické zpracování pomocí sloupcového grafu. ### -- Grafickému oknu nastavíme možnost vytvoření 9 grafů. par(mfrow=c(3,3), mar=c(2,3,3,3),cex=.7) ### -- Použijeme funkci table, která vytvoří z odpovědi faktor (zjistí počet konkrétních odpovědí a graf je správně interpretuje). Každý další příkaz obsahuje modifikaci pro úpravu grafu. barplot(table(mydat[1])) barplot(table(mydat[1],exclude=c(""))) barplot(table(mydat[1],exclude=c("")),main=colnames(mydat[1 ])) barplot(table(mydat[1],exclude=c("")),main=colnames(mydat[1 ]),names.arg = FALSE) barplot(table(mydat[1],exclude=c("")),main=colnames(mydat[1 ]),names.arg = FALSE,args.legend=c(x="topleft")) barplot(table(mydat[1],exclude=c("")),main=colnames(mydat[1 ]),names.arg = FALSE,args.legend=c(x="topleft"),ylim=c(0,70)) barplot(table(mydat[1],exclude=c("")),main=colnames(mydat[1 ]),names.arg = FALSE,args.legend=c(x="topleft"),legend.text=TRUE,ylim=c(0, 70)) barplot(table(mydat[1],exclude=c("")),main=colnames(mydat[1 ]),names.arg = FALSE,args.legend=c(x="topleft"),legend.text=TRUE,ylim=c(0, 70),col=c("red", "green", "blue", "black", "yellow"))
### -- Následující kód upraví délku názvu grafu tak, aby se v případě větší délky rozdělil do více řádků. h1=strsplit(colnames(mydat[1]), " ") k=c("") if (length(h1[[1]])<3) { for(i in 1:2) { k=paste(k,h1[[1]][i],sep=" ") } } if (length(h1[[1]])==3) { for(i in 1:3) { k=paste(k,h1[[1]][i],sep=" ") } } if (length(h1[[1]])==4) { for(i in 1:4) { k=paste(k,h1[[1]][i],sep=" ") } } if (length(h1[[1]])>4) { for(i in 1:4) { k=paste(k,h1[[1]][i],sep=" ") } k=paste(k,"\n",sep="") for(i in 5:length(h1[[1]])) { k=paste(k,h1[[1]][i],sep=" ") } } barplot(table(mydat[1],exclude=c("")),main=k,names.arg = FALSE,args.legend=c(x="topleft"),legend.text=TRUE,ylim=c(0, 70),col=c("red", "green", "blue", "black", "yellow"))
### -- Ukázka zpracování celého dotazníku najednou. ### -- Odstraníme všechny objekty programu, nastavíme pracovní adresář a zjistíme, zda je správně nastaven. rm(list=objects()) setwd("C:/Users/admin/Desktop/r") getwd()
Finální zpracovaní 6 grafů do jednoho obrázku vidíme dole. Celý postup je popsán programovým kódem s vysvětlením.
### -- Načteme a upravíme data z dotazníku, které máme v upravené textové podobě. mydat=read.csv("Uvodni_dotaznik.txt", sep = "\t", header = TRUE, as.is = TRUE) ### -- Přejmenujeme názvy sloupců, protože mezera v textu se po importu upraví na tečku. Tento způsob úpravy není nejvhodnější, ale můžeme jej použít. Alternativou by bylo uložit názvy sloupců do samostatného vektoru, ze kterého by se načitávaly. My je budeme načítat z vytvořené tabulky. colnames(mydat)=c("Zajímá mě oblast IT a čtu informace ze světa IT?","Jak často pracuji s počítačem?","Mám doma vlastní počítač?","K čemu nejčastěji používám počítač?","Jak řeším problémy s počítačem?","Dokážu instalovat software?","Dokážu instalovat hardware?","Pracoval(a) jsem již s notebookem?","Používám flash paměť?","Jak často vypaluji data, hudbu, filmy apod. CD/DVD?","Jak často vytvářím textové dokumenty?","Jak často pracuji s tabulkovým procesorem?","Vytvořil jsem již
vlastní prezentaci k nějaké přednášce?","Umím programovat?","Co pro mě počítač představuje?","Jak bych ohodnotil své schopnosti práce s počítačem?","Vlastním PC/NB?","Jak ovládám práci s programem MS Word?","Jak ovládám práci s programem MS Excel?","Jak ovládám práci s programem MS PowerPoint?","Pracoval(a) jsem někdy s programy OpenOffice?","Umím tisknout s virtuální tiskárnou?","Ovládám vypalovací program Nero?","Vím co znamená pojem souborový manager?","Umím pracovat se styly v textovém editoru?","Vím co jsou a umím vytvářet a používat vlastní makra?","Jaký komprimovací software používám nejčastěji?","Baví mě experimentování s novými programy?","Používám nějaký program společnosti Adobe?","Umím vytvořit graf v MS Excelu a formátovat jeho vlastnosti?","Umím pracovat s funkcemi v MS Excelu?","V jakém operačním systému nejčastěji pracuji?","Rozumím pojmu uživatelský účet?","Pracoval(a) jsem v nějaké síti kromě internetu?","Jak často měním nastavení pozadí na počítači?","Umím pracovat s úpravami hlavního panelu v OS MS Win?","Instaloval(a) jsem někdy operační systém?","Umím nastavit obnovovací frekvenci monitoru?","Vím k čemu se použivá Apache a na jaký OS se instaluje?","Rozumím pojmu HTML/XHTML?","Rozumím pojmu PHP/ASP?","Mám vlastní webovou prezentaci?","Se kterým z vyhledáváčů umím pracovat?","Jak často pracuji na internetu?","Jaký způsob komunikace na internetu používám nejčastěji?","Používám ještě nejaký jiný způsob komunikace?","K čemu nejčastěji využívám internet?","Umím stahovat jakékoliv data (filmy/písničky/obrázky) z internetu?","Stahuji si webové stránky, se kterými pak pracuji off-line?","Rozumím pojmům upload/download?","Umím pracovat s programem MS Outlook Express/MS Outlook/Mozilla Thunderbird?","Jak ovládám práci s programem MS Access?","Rozumím pojmu databáze a vytvářel jsem vlastní databázi?","Myslím, že databáze jsou dnes hodně rozšířené?","Kde se nejčastěji můžu setkat s databázi?","Pracoval(a) jsem někdy s kamerou?","Vytvářím si vlastní videoprojekty/filmy?","Uměl(a) bych sestříhat krátke video v nějakém editoru?","Používám fotoaparát?","Umím pracovat v programu GIMP?","Umím pracovat v programu Photoshop?","Umím pracovat v programu Corel Draw?","Jaký prohlížeč obrázku používám?","Uměl(a) bych vysvětlit pojem bitmapová grafika?","Uměl(a) bych vysvětlit pojem vrstva v bitmapové grafice?","Uměl(a) bych
vysvětlit pojem vektorová grafika?","Používám někdy skener?") ### -- Vytvoříme vektory, které použijeme k načtení sloupců v tabulce. a=1 ### -- Protože vytvoříme 11 obrázků po 6 odpovědích (66 otázek v dotazníku), vytvoříme cyklus s 11 opakováními. for (j in 1:11) { ### -- Nastavíme vlastnosti grafického zařízení a grafu. par(mfrow=c(3,2),mar=c(2,3,3,3),cex=.7) ### -- Vytvoříme cyklus pro vykresleni 6 grafů. for (i in 1:6) { ### -- Následující kód včetně podmíněných výrazů nám upraví názvy sloupců tak, aby se v případě delšího názvu název vypsal do dvou nebo více řádků nad grafem. h1=strsplit(colnames(mydat[a]), " ") k=c("") if (length(h1[[1]])<3) { for(i in 1:2) { k=paste(k,h1[[1]][i],sep=" ") } } else if (length(h1[[1]])==3) { for(i in 1:3) { k=paste(k,h1[[1]][i],sep=" ") } } else if (length(h1[[1]])==4) { for(i in 1:4) { k=paste(k,h1[[1]][i],sep=" ") } } else if (length(h1[[1]])>4) { for(i in 1:4) { k=paste(k,h1[[1]][i],sep=" ") } k=paste(k,"\n",sep="") for(i in 5:length(h1[[1]])) { k=paste(k,h1[[1]][i],sep=" ")
} } ### -- Vykreslime graf. barplot(names.arg = FALSE, main=k,table(mydat[a],exclude=c("")), args.legend=c(x="topleft"), ylim=c(0,70), legend.text=TRUE, col=c("red", "green", "blue", "black", "yellow")) a=a+1 } ### -- Vytvoříme název obrázku s grafy. grafy=paste("grafy_serie",j,sep="") ### -- Uložíme graf a zavřeme grafické zařízení. savePlot(filename = grafy, type = c("tiff")) dev.off() }
Generování dat z rovnoměrného (uniformního) a normálního rozložení Program R dokáže generovat pseudonáhodná čísla. Cílem této ukázky je stručný návod, jak je možné tato čísla generovat a graficky zobrazit. Smyslem je ukázat možnost vytvoření obrázku s grafy jenom pomocí high-level funkcí, v kombinaci s low-level grafickými funkcemi. Výstupy jsou na následujících obrázcích.
### -- Odstraníme všechny objekty programu, nastavíme pracovní adresář a zjistíme, zda je správně nastaven. rm(list=objects()) setwd("C:/Users/admin/Desktop/r") getwd()
### -- Vygenerujeme 5000 náhodných čísel normálního rozložení s průměrem 0 se směrodatnou odchylkou 1. Vygenerované hodnoty uložíme do proměnných y1 a y2. y1=rnorm(5000, mean=0, sd=1) y2=rnorm(5000, mean=0, sd=1) ### -- Zobrazíme histogram, který bude uložen v objektu b1. Po prohlédnutí histogramu zavřeme grafické okno. b1=hist(y1, freq=TRUE, breaks=100) dev.off() ### -- Vygenerujeme 5000 náhodných čísel uniformního rozložení z intervalu [-2,2]. Vygenerované hodnoty uložíme do proměnných x1 a x2. x1=runif(5000, min=-2, max=2) x2=runif(5000, min=-2, max=2) ### -- Zobrazíme histogram, který bude uložen v objektu a1. Po prohlédnutí histogramu zavřeme grafické okno. a1=hist(x1, freq=TRUE, breaks=100) dev.off() ### -- Objekt a1 obsahuje výstupní informace o histogramu vygenerovaných dat z uniformní distribuce. a1 ### -- Vypsáním délky můžeme zjistit, zda se výstupy shoduji. length(a1$breaks) length(a1$counts) length(a1$intensities) length(a1$density) length(a1$mids) ### -- Jednotlivé části výstupních dat můžeme také zobrazit graficky. par(mfrow=c(2,2)) hist(x1, freq=TRUE, breaks=100) plot(a1$mids,a1$counts, ylim=c(0,80)) ### -- Nastavíme oblast pro grafické okno. Vykreslíme 4 grafy a nastavíme jejich okraje. V horní části se vykreslí data z normálního rozložení, dole data z uniformního rozložení. Vykreslíme první bodový graf.
par(mfrow=c(2,2), mar=c(5,5,3,0), cex=.7) plot(y1,y2) ### -- Nastavíme okraje grafu, abychom mohli hned vedle něj vykreslit histogram z vygenerovaných dat. par(mar=c(5,0,3,0)) barplot(a1$density, horiz=TRUE, axes=FALSE,xlim=c(0,0.6)) ### -- Stejným způsobem vykreslíme grafy pro uniformní rozdělení. par(mar=c(5,5,3,0)) plot(x1,x2) par(mar=c(5,0,3,0)) barplot(a1$density, horiz=TRUE, axes=FALSE,xlim=c(0,0.6))
Následující skript vytvoří podobné grafy jako v předcházejícím příkladu, ale při vytváření použijeme i low-level funkce. ### -- Odstraníme všechny objekty programu, nastavíme pracovní adresář a zjistíme, zda je správně nastaven. rm(list=objects()) objects() setwd("C:/Users/admin/Desktop/plots") ### -- Vygenerujeme pseudonáhodná čísla. y1=rnorm(1000, mean=0, sd=1) y2=rnorm(1000, mean=0, sd=1) x1=runif(5000, min=-2, max=2) x2=runif(5000, min=-2, max=2) y=hist(y1, freq=TRUE, breaks=100) dev.off() x=hist(x1, freq=TRUE, breaks=100) dev.off() ### -- Vytvoříme první obrázek se dvěma grafy (bodový a histogram). ### -- Nastavíme velikost grafického okna. windows(width=2, height=1.5, xpinch=300, ypinch=300, gamma=1.5) ### -- Nastavíme vlastnosti grafického zařízení a grafu. Argument fig nastavuje oblast grafického zařízení pro vykreslení grafu (2/3 oblasti zleva) a vykreslíme první graf.
par(fig=c(0,.75,0,1),mar=c(3,3,4,0), font.axis=2, font.main=2, font.sub=2, cex.axis=1.1, cex.main=1.1, cex.sub=1.1) plot(y1,y2, type="n", xlim=c(-3,3),ylim=c(-3,3), ann=FALSE) points(y1,y2, pch=21, bg="red") title("Hustota normálního rozdělení", side = 3, line = 2) mtext("(generováno 1000 čísel s parametry sigma=0, -1)", side = 3, line = 1) ### -- Nastavíme vlastnosti grafického zařízení a grafu. Argument fig nastavuje oblast grafického zařízení pro vykreslení grafu (1/3 oblasti zprava). Vykreslíme druhý graf. par(new=TRUE, fig=c(0.75,1,0,1),mar=c(3,0,4,0)) barplot(y$density, horiz=TRUE, axes=FALSE,xlim=c(0,0.6), space=5, ann=FALSE)
### -- Vytvoříme druhý obrázek stejným způsobem jako předcházející. windows(width=2, height=1.5, xpinch=300, ypinch=300, gamma=1.2) par(fig=c(0,.75,0,1),mar=c(3,3,4,0)) plot(x1,x2,xlim=c(-3,3),ylim=c(-3,3), ann=FALSE) points(x1,x2, pch=21, bg="green") title("Hustota uniformního rozdělení", side = 3, line = 2) mtext("(generováno 1000 čísel s parametry min=-2, max=2)", side = 3, line = 1) par(new=TRUE, fig=c(0.75,1,0,1),mar=c(3,0,4,0)) barplot(x$density, horiz=TRUE, axes=FALSE,xlim=c(0,0.6), space=5, ann=FALSE)
Vytvoření bublinového grafu Bublinový graf je bodovým grafem, který je schopen kromě dvou dimenzí zobrazit další třetí dimenzi, a to prostřednictvím velikosti bubliny. To znamená, že kromě hodnot x a y je možné zobrazit i hodnotu z. V příkladu jsou data, která souvisí s množstvím nakladených vajíček komárů v průběhu letního období. Kromě závislosti množství kladených vajíček na měsíci v roku můžeme pomocí bublinového grafu vyjádřit i procento vylíhnutých larev. Výstupem je graf, který vidíme na následujícím obrázku.
### -- Odstraníme všechny objekty programu, nastavíme pracovní adresář a zjistíme, zda je správně nastaven rm(list=objects()) objects() setwd("C:/Users/uzivatel/Desktop/plots") ### -- Připravíme data vytvořením tří vektorů. Vektor měsíc obsahuje hodnoty pro označení měsíce, vektor vajíčka pro množství nakladených vajíček v daném měsíci a vektor perc, procentualní vylíhnutí vajíček. mesic=c("V", "VI", "VII", "VIII", "IX", "X") vajicka=c(400, 650, 705, 800, 690, 200) perc=c(.22000, .48384, .57456, .90720, .75600, .30240) ### -- Otevřeme grafické zařízení a nastavíme jeho vlastnosti a vlastnosti grafu. windows(width=2.5, height=2, xpinch=300, ypinch=300, gamma=1.5) par(mar=c(5,6,7,5), xaxs="i", yaxs="i", las=1, font.axis=2, cex.axis=1, cex.main=1.5) ### -- Vytvoříme nový graf a nastavíme vlastnosti osy x a y a způsob jejich vykreslení do grafu. plot.new()
plot.window(ylim=c(100,900),xlim=c(0,7), xaxs="i", yaxs="i") ### -- Vytvoříme osy x a y v definovaném rozsahu na stanoveném místě. axis(1,at=c(1:6), labels=mesic) axis(2, at=seq(100, 900, by=100), tick=FALSE) axis(4, at=seq(100, 900, by=100), tick=FALSE) ### -- Vytvoříme pozadí grafu a ohraničení pozadí. polygon(x=c(0,7,7,0), y=c(0,0,900,900), col="#f7f2e1") box() ### -- Vytvoříme vodorovnou a svislou mřížku grafu. for (j in seq(200, 800, by=100)) { abline(h=j, lty=4) } for (i in 1:6) { abline(v=i, lty=4) } ### -- Vytvoříme nadpis, podnadpis grafu a popisky os. title("Závislost množství kladených vajíček\nna ročném období v okolí Ústí nad Labem", line=3) mtext("(velikost bublin představuje procento vylíhnutí data z roku 2003)", side=3, line=1) mtext("počet vajíček v 1 dm3 vody", side=2, line=4, las=0, font=2) mtext("měsíc", side=1, line=3, las=0, font=2) ### -- Vytvoříme symboly bublin. Procentuelní hodnotu zmenšíme násobením číslem 0.4. symbols(x=c(1:6), vajicka, circles=perc*.4, xlim=c(0,7), ylim=c(100,900), bg="blue", inches=FALSE, axes=FALSE, ann=FALSE, add=TRUE) ### -- použité funkce
Vytvoření více os v jednom grafu (2 grafy v jednom) Pomocí low-level funkcí můžeme vytvářet grafy i tzv. od nuly. Výhodou je možnost nastavení rozsahu pro každou osu zvlášť v případech, kdy chceme vynést do grafu více souvisejících dat.
Data, která vyneseme do grafu, prezentují závislost množství získané sušiny na ročním období. K těmto datům vyneseme i data průměrných teplot pro dané období. V jednom grafickém zařízení vytvoříme 4 stejné grafy s rozdílnou barvou.
### -- Odstraníme všechny objekty programu, nastavíme pracovní adresář a zjistíme, zda je správně nastaven rm(list=objects()) setwd("C:/Users/admin/Desktop/r") getwd() ### -- Načteme data z externího souboru do tabulky a tabulku vypíšeme. V případě použití mezer v názvech zahlaví sloupců je vhodnější je přejmenovat. Případně vypustit diakritiku.
mydata=read.table("susina.csv", header=TRUE, sep=";", as.is = TRUE) mydata ### -- Přejmenujeme názvy sloupců a znovu vypíšeme tabulku. colnames(mydata)=c("měsíc","množství sušiny","průměrná teplota") mydata
### -- Otevřeme grafické zařízení, nastavíme oblasti pro vykreslení grafu a nastavíme vlastnosti grafu. windows() par(mfrow=c(2,2), mar=c(4,5,4,5), cex.main=1.1) ### -- Vytvoříme cyklus s opakováním pro vykreslení 4 grafů. Proměnná j nabývá hodnoty 1, 2, 3, 4. for (j in 1:4) { ### -- Nejprve vytvoříme sloupcový graf. plot.new() plot.window(ylim=c(0,8000), xlim=c(0,length(mydata[,2])+1), xaxs="i") axis(2) ### -- Vykreslíme sloupce grafu. for (i in 1:length(mydata[,2])) { polygon(c(i-.2,i+.2,i+.2,i-.2), c(0,0,mydata[,2][i], mydata[,2][i]), col=j) } ### -- Vytvoříme bodový graf. plot.window(ylim=c(0,20),xlim=c(0,length(mydata[,2])+1)) axis(4) axis(1,at=c(1:5), labels=mydata[,1], tck=-0.01) points(mydata[,3], col=j+1, type="b", bg="black", xaxs="i") ### -- Vytvoříme nadpis grafu a popisky jednotlivých os. Znak \n se používá pro zalomení textu v textových řetězcích. title("Vztah mezi průměrnou měsíční teplotou\na množstvím získané sušiny a na ploše 1 ha") mtext("množství sušiny", side=2, line=3, las=0, cex=.9) mtext("průměrná teplota", side=4, line=3, las=0, cex=.9) mtext("měsíc", side=1, line=3, las=0, cex=.9) }
### -- Graf uložíme ve formátu tiff s nazvem 2v1 a zavřeme grafické zařízení. savePlot(file="2v1", type = c("tiff")) dev.off()
Lineární regresní model Příklad je zaměřen na ukázku pro výpočet základních parametrů lineárního modelu. Jako příklad nám poslouží měřená data jedné závislé (maximální srdeční tepová frekvence) a jedné nezávislé proměnné (věk). Základní matematické vyjádření lineárního modelu můžeme zapsat jako
kde x je nezávislá (náhodná) proměnná, y je závislá proměnná a parametry lineárního modelu jsou a a b. Výstupem bude zobrazení naměřených dat, získání parametrů lineární funkce a zobrazení fitovaných hodnot včetně konfidenčního a predikčního intervalu.
### -- Odstraníme všechny objekty programu, nastavíme pracovní adresář a zjistíme, zda je správně nastaven. rm(list=objects()) setwd("C:/Users/admin/Desktop/r") getwd() ### -- Připravíme data. Vektor věk bude obsahovat objekt x a vektor max_frek bude obsahovat objekt y. vek=c(18, 23, 25, 35, 65, 54, 34, 56, 72, 19, 23, 42, 18, 39, 37) max_frek=c(202, 186, 187, 180, 156, 169, 174, 172, 153, 199, 193, 174, 198, 183, 178) x=vek y=max_frek ### -- Vyhodnocení regresního modelu. lm(y ~ x) ### -- Uložení výstupu regresního šetření do objektu res a zobrazení přehledu. res=lm(y ~ x) summary(res) ### -- Grafické zobrazení výstupu regresního šetření. par(mfrow=c(2,2)) plot(res) ### -- Vytvoření čtyč grafů. windows() par(mfrow=c(2,2), mar=c(4,4,4,2)) ### -- Graf s naměřenými daty. plot(x,y, ann=F) title("Závislost tepove frekvence na věku", line=2) mtext("věk", side=1, line=3, font=2, cex=0.8) mtext("max.tepová frekvence", side=2, line=3, font=2, cex=0.8) ### -- Graf s naměřenými daty, přímkou lineárního modelu s fitovanými parametry a fitovanými hodnotami (červená – fitované hodnoty y pro věk, modrá – fitované hodnoty pro vybrané věkové skupiny). plot(x,y) abline(lm(y ~ x))
title("Závislost tepove frekvence na věku", line=2) mtext("věk", side=1, line=3, font=2, cex=0.8) mtext("max.tepová frekvence", side=2, line=3, font=2, cex=0.8) mtext("(fitovane hodnoty)", side=3, line=1, font=2, cex=0.8) ### -- Fitované hodnoty. points(sort(x),sort(fitted(res), decreasing=TRUE), col="red") ### -- Predikované hodnoty pro dané x. points(x=c(28,29,30),predict(res, data.frame(x=c(28,29,30))), col="blue") ### -- Graf s naměřenými daty, přímkou lineárního modelu s fitovanými parametry, fitovanými hodnotami (červená – fitované hodnoty y pro věk, modrá – fitované hodnoty pro vybrané věkové skupiny) a konfidenčními intervaly (červená). plot(x,y) abline(lm(y ~ x)) title("Závislost tepove frekvence na věku", line=2) mtext("věk", side=1, line=3, font=2, cex=0.8) mtext("max.tepová frekvence", side=2, line=3, font=2, cex=0.8) mtext("(predikční interval)", side=3, line=1, font=2, cex=0.8) ### -- Fitované hodnoty. points(sort(x),sort(fitted(res), decreasing=TRUE), col="red") ### -- Predikované hodnoty pro dané x. points(x=c(28,29,30),predict(res, data.frame(x=c(28,29,30))), col="blue") ### -- Vykreslíme konfidenční intervaly. x1=20:70 data.frame(x=20:70) points(x1,predict(res, data.frame(x=20:70), level=.99, interval="confidence")[,2], pch=21, col="red", type="l") points(x1,predict(res, data.frame(x=20:70), level=.99, interval="confidence")[,3], pch=21, col="red", type="l") ### -- Graf s naměřenými daty, přimkou lineárního modelu s fitovanými parametry, fitovanými hodnotami (červená – fitované hodnoty y pro věk, modrá – fitované hodnoty pro
vybrané věkové skupiny), konfidenčními intervaly (červená) a predikčními intervaly (zelená). plot(x,y) abline(lm(y ~ x)) title("Závislost tepove frekvence na věku", line=2) mtext("věk", side=1, line=3, font=2, cex=0.8) mtext("max.tepová frekvence", side=2, line=3, font=2, cex=0.8) mtext("(predikční a konfidenční interval)", side=3, line=1, font=2, cex=0.8) ### -- Fitované hodnoty. points(sort(x),sort(fitted(res), decreasing=TRUE), col="red") ### -- Predikované hodnoty pro dané x. points(x=c(28,29,30),predict(res, data.frame(x=c(28,29,30))), col="blue") ### -- Vykreslíme konfidenční intervaly. x1=20:70 data.frame(x=20:70) points(x1,predict(res, data.frame(x=20:70), level=.99, interval="confidence")[,2], pch=21, col="red", type="l") points(x1,predict(res, data.frame(x=20:70), level=.99, interval="confidence")[,3], pch=21, col="red", type="l") ### -- Vykreslíme predikční intervaly. points(x1,predict(res, data.frame(x=20:70), level=.99, interval="prediction")[,2], pch=21, col="green", type="l") points(x1,predict(res, data.frame(x=20:70), level=.99, interval="prediction")[,3], pch=21, col="green", type="l")
Nelineární regresní model Tento příklad je zaměřen na ukázku výpočtu základních parametrů nelineárního modelu. Jako příklad nám poslouží data z měření rychlosti enzymové aktivity. Základní matematické vyjádření vztahu mezi rychlostí enzymové reakce a koncentrací substrátu se jmenuje rovnice Michaelise a Mentenové a má tvar
kde Vmax je maximální (limitní) rychlost enzymové reakce, KM je Michaelisová konstanta (koncentrace substrátu, při které se rychlost enzymové
reakce rovná právě jedné polovině maximální rychlosti Vmax) a [S] je koncentrace substrátu. Proto se pro výpočet základních parametrů experimentálně naměřená data „nafitují“ pomocí matematické funkce nelineárního modelu. Základní matematická funkce pro fitování má tvar
kde a je hodnota Vmax, b je hodnota KM a hodnoty x jsou experimentálně naměřené hodnoty. Vypočtené hodnoty a legenda grafu se vykreslí do grafu na místě dvojitého kliknutí s použitím funkcí interaktivní grafiky.
### -- Odstraníme všechny objekty programu, nastavíme pracovní adresář a zjistíme, zda je správně nastaven. rm(list=objects()) setwd("C:/Users/admin/Desktop/r") getwd() ### -- Vytvoříme číselné vektory obsahující data. Vektor konc obsahuje naměřené koncentrace a vektor rych hodnoty rychlosti enzymové reakce.
konc=c(0.2, 0.4, 0.6, 0.8, 1, 1.2, 1.4, 1.6, 1.8, 2, 2.2, 2.4, 2.6, 2.8, 3, 4, 5, 6, 7, 8) rych=c(0.1492, 0.2168, 0.2532, 0.2795, 0.2915, 0.3162, 0.3177, 0.334, 0.3326, 0.3407, 0.3334, 0.3408,0.3537, 0.3471, 0.3556, 0.3663, 0.3665, 0.3638, 0.3719, 0.3833) ### -- Z vytvořených vektorů můžeme vytvořit tabulku, kterou zapíšeme v podobě textového souboru na disk do pracovního adresáře. Tabulku můžeme zpětně načíst a pracovat s daty. write.table(data.frame(konc,rych), file="data_MM.txt") data.MM = read.table("data_MM.txt", header=T, sep=" ") data.MM ### -- Data vložíme do vektoru x a y. x=konc y=rych ### -- Vytvoříme funkci, kterou použijeme pro výpočet parametru nelineárního modelu. fc=function(x,a,b) { (a*x)/(b+x) } ### -- Výsledek nelineárního modelu můžeme uložit do objektu reg. Můžeme pro výpočet použít přímo naší rovnici, případně vytvořenou funkci. reg=nls(y~(a*x)/(b+x), start=c(a=1,b=1)) reg=nls(y~fc(x,a,b), start=c(a=1,b=1)) ### -- Výstupy výpočtu parametru můžeme zobrazit různým způsobem, včetně vypočtených parametrů (funkce coef())koeficientu. summary(reg) coef(reg) ### -- Vytvoříme vektory, které obsahují souřadnice pro vykreslení bodu Km do grafu. x1=coef(reg)[2] y1=fc(x1, coef(reg)[1], coef(reg)[2]) ### -- Vytvoříme grafické zařízení a nastavíme jeho vlastnosti a vlastnosti grafu.
windows(width=2.5, height=2, xpinch=300, ypinch=300, gamma=1.5) par(mar=c(5,6,5,5), xaxs="i", yaxs="i", las=1, font.axis=2) plot.new() plot.window(ylim=c(-.04,.44),xlim=c(-.4,8.4), xaxs="i", yaxs="i") ### -- Vykreslíme pozadí grafu. polygon(x=c(-.4,8.4,8.4,-.4), y=c(-.04,-.04,.44,.44), col="#ececec") ### -- Vykreslíme ticks. axis(1, at=seq(0,8, by=2), tck=.026, lwd.ticks=1.8) axis(2, at=seq(0,.4, by=.1), tck=.026, lwd.ticks=1.8) axis(4, at=seq(0,.4, by=.1), tck=.026, lwd.ticks=1.8) axis(1, at=seq(-.4,8.4, by=.2), tck=.01, labels=FALSE) axis(2, at=seq(-.04,.44, by=.02), tck=.01, labels=FALSE) axis(4, at=seq(-.04,.44, by=.02), tck=.01, labels=FALSE) ### -- Vykreslíme fitovanou křivku. curve(fc(x, coef(reg)[1], coef(reg)[2]), from=0, to=8, add = TRUE) ### --Vykreslíme naměřená data. points(x,y, pch=21, bg="blue") ### -- Vykreslíme bod, který představuje hodnotu Km. points(x1,y1, pch=21, bg="red") lines(x=c(x1,x1),y=c(0,y1), col="red", lty=2) lines(x=c(0,x1),y=c(y1,y1), col="red", lty=5) ### -- Můžeme zaokrouhlit získané hodnoty parametru. vmax=round(coef(reg)[1], digits=3) km=round(coef(reg)[2], digits=3) y2=round(y1, digits=3) ### -- Vykreslíme název grafu a osy x a y. mtext("Vyhodnocení experimentálních dat\ntzv. fitováním matematického modelu", side=3, line=2, font=2, cex=1.3) mtext("počáteční rychlost", side=2, line=3, font=2, las=0) mtext("koncentrace", side=1, line=3, font=2)
### -- Určíme, dvojitým kliknutím do grafu oblast, do které se vypíší popisky s fitovanými hodnotami. První kliknutí znamená horizontální centovani popisků, druhé vertikální. p1=locator(1)[1] p2=locator(1)[2] ### -- Získané hodnoty můžeme vypsat. p1; p2 ### -- Vytvoříme objekt (textový vektor) – použijeme ho jako popisek pro výpis parametrů. tt=paste("hodnoty parametrů:\na(Vmax) = ",vmax,"\na/2 (Vmax/2) = ",y2,"\nb (KM) = ",km, sep="") ### -- Vytvořený popisek vypíšeme. text(x=p1, y=p2, labels=tt, font=2, cex=.9) ### -- Vypočteme koordináty pro výpis legendy. p11=p1$x-1.5 p12=p1$x+1.5 p21=(p2$y-0.06)+.125 p22=(p2$y+0.06)+.125 ### -- Koordináty pro vypsání popisků a grafických prvků legendy. p21+((p22-p21)/6)*1 p21+((p22-p21)/6)*3 p21+((p22-p21)/6)*5 p11+(p12-p11)/4 p11+((p11+(p12-p11)/4)-p11)/2 ### -- Vytvoříme popisky legendy. polygon(x=c(p11,p12,p12,p11), y=c(p21,p21,p22,p22), col="white") text(p11+(p12-p11)/4, (p21+((p22-p21)/6)*1)+.015, labels="hodnoty parametrů", adj=0, font=2, cex=.9) text(p11+(p12-p11)/4, p21+((p22-p21)/6)*3, labels="naměřené hodnoty", adj=0, font=2, cex=.9) text(p11+(p12-p11)/4, (p21+((p22-p21)/6)*5)-.015, labels="regresní křivka", adj=0, font=2, cex=.9) ### -- Vytvoříme grafické prvky legendy. points(p11+((p11+(p12-p11)/4)-p11)/2, (p21+((p22p21)/6)*1)+.015,pch=21, bg="red")
points(p11+((p11+(p12-p11)/4)-p11)/2, (p21+((p22p21)/6)*3),pch=21, bg="blue") lines(x=c((p11+((p11+(p12-p11)/4)-p11)/2).15,(p11+((p11+(p12-p11)/4)-p11)/2)+.15), y=c((p21+((p22p21)/6)*5)-.015,(p21+((p22-p21)/6)*5)-.015)) ### -- Graf uložíme ve formátu tiff s názvem MM a zavřeme grafické zařízení. savePlot(file="MM", type = c("tiff")) dev.off()
Populační model dravec-kořist Populační model dravec-kořist je jedním z jednodušších modelů populační dynamiky. Popisuje vývoj populace dravce a vývoj populace kořisti s cílem zjištění mechanizmu vzájemné koexistence obou druhů v ohraničeném území. Autorem tohoto modelu je V. Volterra a A. J. Lotka, proto se tento model také nazývá Lotka-Volterra model. Model má 2 předpoklady, a to, že kořist má neomezený přístup k potravě a její úbytek je závislý pouze na přítomnosti dravce (predace) a že růst populace dravce je závislá jen na přítomnosti kořisti (predace) a přirozené úmrtnosti. Model obsahuje 2 základní rovnice pro časovou změnu velikosti populace obou druhů:
kde první rovnice představuje změnu velikosti populace kořisti (R) a druhá změnu velikosti populace dravce (P), a (faktor množení kořisti), b (koeficient predace), c (reprodukční míra predátora závislá na kořisti), d (faktor úhynu predátora) jsou parametry rovnice. Kdyby neexistoval predátor, kořist by rostla exponenciálně, pozitivní první člen první rovnice. Za přítomnosti predátora kořisti ubývá, negativní druhý člen první rovnice. Za přítomnosti kořisti populace predátora může růst, pozitivní první člen druhé rovnice. V prostředí dochází k přirozenému úbytku predátora (úmrtnost), negativní druhý člen druhé rovnice. Rovnice můžeme řešit analyticky nebo numericky. Numerický výpočet zjednodušíme pomocí Eulerovy metody a můžeme ho řešit pomocí programu MS Excel, viz obrázek níže.
Stanovíme předpoklad, že v čase t0 je velikost populace x(t0). V čase t0+Δt můžeme odhadnout velikost populace za předpokladu, že zvolíme interval Δt velmi krátký, viz obrázek.
Výsledkem jsou dvě rovnice
kde R(t+1) je velikost populace v následujícím kroku, Rt je velikost populace v předcházejícím kroku a ΔR je změna populace za časový krok Δt. Pokusíme se o vytvoření řešení v programu MS Excel. Vycházíme z předpokladu dané velikosti obou populací R a F. V MS Excel vytvoříme a vyplníme tabulku podobně jako na obrázku dole a vytvoříme požadované grafy.
Do populačního grafu vyneseme na osu x čas a na osu y velikost populace kořisti (R) a dravce (P). Do populační křivky vyneseme na jednu osu velikost jedné populace a na druhou osu velikost druhé populace. Následně problém řešíme pomocí programu R. Ukázka výstupu je zobrazena na obrázku níže.
### -- Odstraníme všechny objekty programu, nastavíme pracovní adresář a zjistíme, zda je správně nastaven. rm(list=objects()) setwd("C:/Users/admin/Desktop/r") getwd() ### -- Definujeme funkci pro výpočet změny velikosti populace králíka a lišky. Del_R=function(a, b, Ra, Fo) { (a*Ra)-(b*Ra*Fo) } Del_F=function(c, d, Ra, Fo) { (c*Ra*Fo)-(d*Fo) } ### -- Definujeme parametry pro výpočet. Ra=22 Fo=3 a=0.9 b=0.2 c=0.1 d=1
### -- Definujeme velikost časové jednotky, pro kterou se vypočte změna velikosti populace králíka a lišky. T_Del=0.008 T_0=0 T_N=25 Length=length(seq(T_0, T_N, T_Del)) ### -- Nastavíme vlastnosti grafického zařízení a počet grafů, které se do něj vypíší. windows(9,6) par(mfcol=c(2,3), mar=c(4,4,3,4)) ### -- Vytvoříme cyklus pro vytvoření 3 různých podmínek pro výpočet velikosti obou populací. Měníme jenom parametr b. Pro 3 různé podmínky se vytvoří 2 grafy (populační graf a fázový diagram). for (b in c(0.6, 0.4, 0.2)) { ### -- Vždy pro dané podmínky vytvoříme samostatnou tabulku, která bude obsahovat data podobně jako v ukázce Excelovské tabulky nahoře. rm(Results) Results=data.frame(Del_Time=seq(T_0, T_N, T_Del), Del_Rabbits=numeric(Length), Del_Foxes=numeric(Length), Rabbits=numeric(Length), Foxes=numeric(Length)) ### -- Vyplníme první řádek tabulky podobně jako v tabulce v MS Excel. Results$Rabbits[1]=Ra Results$Foxes[1]=Fo ### -- Vyplníme obsah tabulky pro zadaný čas. for (e in 2:Length) { Results[e, 2]=T_Del*((a*Results[e-1, 4])-(b*Results[e1, 4]*Results[e-1, 5])) Results[e, 3]=T_Del*((c*Results[e-1, 4]*Results[e-1, 5])-(d*Results[e-1, 5])) Results[e, 4]=Results[e-1,4]+Results[e,2] Results[e, 5]=Results[e-1,5]+Results[e,3] } ### -- Vytvoříme populační graf. plot.new() plot.window(xlim=c(-5,30),ylim=c(0,30), xaxs="i")
points(Results$Del_Time, Results$Rabbits, type="l", col="blue") points(Results$Del_Time, Results$Foxes, type="l", col="red") axis(1, at=seq(0,25,5)) axis(2, col="blue") axis(4, col="red") title(paste("vývoj populace v čase pro\na=",a," b=",b," c=",c," d=",d)) mtext("čas", side=1, line=2, cex=.8, font=2) mtext("populace kořisti (králik)", side=2, line=2, cex=.8, font=2) mtext("populace dravce (líška)", side=4, line=2, cex=.8, font=2) ### -- Vytvoříme fázový diagram. plot.new() plot.window(xlim=c(-5,30),ylim=c(-2,12), xaxs="i") points(Results$Rabbits, Results$Foxes, type="l") axis(1, at=seq(0,25,5), col="blue") axis(2, at=seq(0,10,2), col="red") title("fázový diagram") mtext("populace kořisti (králik)", side=1, line=2, cex=.8, font=2) mtext("populace dravce (líška)", side=2, line=2, cex=.8, font=2) } ### -- Uložíme obrázek s grafy a vypneme grafické zařízení. savePlot(filename="rabbit_foxes", type=c("tiff")) dev.off()
Spektra ELISA testu Příklad je zaměřen na ukázku možnosti grafické prezentace dat, které zobrazují intenzitu meřené vlastnosti. Je zde použit příkaz image(), který umožňuje vytvořit obrázek s mřížkou a s obdélníky v barvách odstínu šedé, případně obdélníky barevné. Intenzita zabarvení odpovídá hodnotám matice. Tato funkce umožňuje zobrazovat trojrozměrné obrázky, u kterých z rozměr představuje intenzitu. Do grafického zařízení nejprve vykreslíme obrázek a pod něj graf znázorňující hodnoty v obrázku. Je zde použita interaktivní grafika pro nakreslení legendy druhého grafu.
### -- Odstraníme všechny objekty programu a nastavíme pracovní adresář a zjistíme, zda je správně nastaven. rm(list=objects()) setwd("C:/Users/admin/Desktop/r") getwd() ### -- Načteme data z datového souboru ve formátu txt. elisa.Data = read.table("text.txt", header=T, sep="\t", colClasses = "character") ### -- Přejmenujeme sloupce v objektu elisa.Data. colnames(elisa.Data) = c(0:12) ### -- V tabulce nahradíme čárku tečkou. for (j in 1:8) { for (i in 2:13) { elisa.Data[j,i] = sub(",", ".", elisa.Data[j,i]) }
} ### -- Nastavíme vlastnosti prvků sloupců na numeric, ne character. for (i in 2:13) { elisa.Data[i] = as.numeric(elisa.Data[,i]) } ### -- Vytvoříme z datové tabulky matici elisa.M, kterou použijeme pro vytvoření grafu pomocí funkce image(). elisa.M=as.matrix(elisa.Data[,2:13]) elisa.M ### -- Nastavíme názvy sloupců a řádků. sloupec = c("A","B","C","D","E","F","G","H","I","J","K","L") radek = c(8:1) ### -- Vytvoříme funkci na zjištění, zda je číslo sudé nebo liché - vytvoření mřížky v grafu. is.Even <- function(x){ x %% 2 == 0 } ### -- Transponujeme matici, abychom mohli vytvořit horizontální graf. elisa.M=t(elisa.M) par(mfrow=c(2,1), mar=c(1,5,4,1)) ### -- Vytvoříme graf. image(elisa.M, col = gray((256:0)/256), ann=FALSE, axes=F ) title("Vynesení hodnot absorbance ve stupních šedé", side=3, line=3) mtext("(dle intenzity v ELISA mikrodestičce)", side=2, line=3, font=2) axis(3, at=seq(from=0, to=1, by=1/11), labels=sloupec) axis(2, at=seq(from=0, to=1, by=1/7), labels=radek, las=1) box() ### -- Vytvoříme mřížku horizontální. w=1 for (i in seq(from=0, to=1, by=1/14)) { if (is.Even(w)==T) { abline(h=i, lty=4, col="black") } w=w+1
} ### -- Vytvoříme mřížku vertikální. w=1 for (i in seq(from=0, to=1, by=1/22)) { if (is.Even(w)==T) { abline(v=i, lty=4, col="black") } w=w+1 } ### -- Vytvoříme druhý graf. Nejprve vyneseme data z prvního řádku. par(mar=c(3,5,2,1)) barva = c("black","darkblue","red","blue","darkgreen","yellow","pin k","blue") plot(elisa.M[,1], col = barva[1], type="b", ylim=c(0,3.5), xlab=c(1:12), main="GRAF", lwd=2, ann=F, axes=F) title("Vynesení hodnot absorbance dle obázku nahoře", side=3, line=1) mtext("absorbance", side=2, line=3, font=2) axis(1, at=1:12, labels=LETTERS[1:12], tick=T) axis(2, at=0:3, tick=T) box() ### -- Vyneseme data do grafu (2. až 8. řádek. for (i in 2:8) { points(elisa.M[,i], col=barva[i], type="b", lwd=2) } ### -- Vytvoří obsah legendy. legenda=vector() for (i in 8:1) { legenda=c(legenda, paste("řádek ", i)) } ### - Kliknutím určíme levý horní okraj legendy. Hodnota pozice je součástí objektu x (je to seznam). x=locator(1) ### - Vypíše legendu. legend(x$x, x$y, legend=legenda, fill=barva, col=barva, border = "black")
Zpracování dat ze spektrofotometru Příklad ukazuje jednoduché vynesení experimentálních dat do grafu. Data byla naměřena spektrofotometrem a exportována do textového souboru. Měření obsahují různé koncentrace stanovované látky. Výstupem je pět grafů, které mají různé umístění na grafickém zařízení windows() a různou barvu řad.
### -- Odstraníme všechny objekty programu, nastavíme pracovní adresář a zjistíme, zda je správně nastaven. rm(list=objects()) setwd("C:/Users/admin/Desktop/r") getwd() ### -- Spustíme grafické zařízení a nastavíme jeho šířku a výšku. windows(width=9.5, height=6) ### -- Grafické zařízení nastavíme pro vykreslení osmi grafů. Budeme vykreslovat jenom 5. par(mfrow=c(2,4), mar=c(4,5,4,1)) ### -- Vytvoříme cyklus pro vykreslení osmi grafů. for (j in 1:8) {
### -- Vytvoříme podmínku, dle které se v grafickém zařízení nevykreslí druhý, třetí a čtvrtý graf. if (j == 2 | j == 3 | j ==4) { ### -- Vykreslení prázdného grafu do prvního řádku na druhou, třetí a čtvrtou pozici. plot.new() } else { ### -- Vytvoříme objekt, který bude obsahovat jména souboru pro zpracovani dat. Soubor = c("MS01.txt", "MS02.txt", "MS03.txt", "MS04.txt", "MS02.txt", "MS03.txt", "MS05.txt", "MS04.txt") ### -- Načtení dat ze souboru typu .txt. data.S = read.table(Soubor[j], header=T, sep="\t", colClasses = "character") ### -- Odstranění prvních 6 řádků. Řádky neobsahují data, ale popisky (výstup ze spektrofotometru, přejmenování sloupců a kontrola dat. a = data.S[-c(1:8),] colnames(a) = c("nm", "Absorbance") a[1:10,] ### -- Úprava dat. Nahradi "," za ".". Důležité pro práci s čísly. for (i in 1:length(a$nm)) { a$nm[i] = sub(",", ".", a$nm[i]) a$Absorbance[i] = sub(",", ".", a$Absorbance[i]) } ### -- Převod obsahu obou sloupců z character na numeric. a$nm = as.numeric(a$nm) a$Absorbance = as.numeric(a$Absorbance) ### -- Vytvoření nadpisu pro grafy. Nadpis = c("pure water", "", "", "", "FECY concentration 19.00 mM", "FECY concentration 3.80 mM", "FECY concentration 1.90 mM", "FECY concentration 0.38 mM") ### -- Vytvoření grafů. plot(a$nm, a$Absorbance, pch=".", xlim=c(150,900), ylim=c(0,6), main=Nadpis[j], ann=F, col=j+3) title(Nadpis[j])
mtext("vlnová délka", side=1, line=3, font=2, cex=0.8) mtext("absorbance", side=2, line=3, font=2, cex=0.8) } ### -- Odstranění všech vytvořených objektů tak, aby se mohl vytvořit nový graf z nových dat. rm(list=objects()) }
Vytvoření krabicového grafu Krabicový graf nebo diagram (boxplot) je grafem, který se používá v popisné statistice a graficky zobrazuje základní popisní statistiky (medián, horní a dolní kvartil, odlehlé hodnoty apod.). V tomto příkladu si vytvoříme dva obrázky s krabicovými grafy. První bude obsahovat 3 grafy vytvořené různými způsoby čtení dat z vytvořené tabulky. Ve druhém bude jeden graf, barevně naformátován.
### -- Odstraníme všechny objekty programu, nastavíme pracovní adresář a zjistíme, zda je správně nastaven. rm(list=objects()) setwd("C:/Users/admin/Desktop/r") getwd()
### -- Připravíme data. Vytvoříme 2 vektory, ze kterých následně vytvoříme dvě tabulky dat (2 varianty vytváření tabulky). muzi=c(58, 57, 48, 73, 83, 85, 74, 65, 74, 72, 79, 81, 69, 63) zeny=c(54, 45, 59, 64, 52, 58, 56, 55, 60, 54, 50, 55, 57, 51, 68, 45, 55, 67, 64) mydataA=data.frame(vaha=c(muzi,zeny), skupiny=c(rep("muži", length(muzi)), rep("ženy", length(zeny)))) mydataB=data.frame(muzi=c(muzi,rep(NA, 5)), zeny) ### -- Prohlédneme data. mydataA mydataA ### -- Vytvoříme první obrázek se třemi grafy, uložíme ho na pevný disk do pracovního adresáře a zavřeme grafické zařízení. par(mfrow=c(1,3)) boxplot(muzi, zeny) boxplot(mydataA$vaha~mydataA$skupiny) boxplot(mydataB$muzi,mydataB$zeny) savePlot(filename="boxplotA1", type=c("png")) dev.off() ### -- Vytvoříme druhý obrázek. ### -- Nastavíme vlastnosti grafického zařízení a vlastnosti grafu. windows(width=2, height=2, xpinch=300, ypinch=300, gamma=1.5) par(mar=c(4,5,5,5), xaxs="i", yaxs="i", las=1, font.axis=2, font.lab=2, cex.lab=1.2, cex.main=1.5) ### -- Vytvoříme graf a nastavíme vlastnosti osy x a y. plot.new() plot.window(ylim=c(38,92),xlim=c(0,3), xaxs="i", yaxs="i") ### -- Vytvoříme pozadí grafu. polygon(x=c(0,3,3,0), y=c(0,0,92,92), col="yellow") ### -- Vytvoříme graf s požadovanými vlastnostmi. Hodnota atributu add=TRUE znamená, že do již otevřeného grafu přidám další, a to krabicový graf.
boxplot(muzi, zeny, width=c(20,30), outline = TRUE, names=c("muži", "ženy"), ylim=c(38,92), col="grey", add=TRUE, ylab="hmotnost [kg]") ### -- Vytvoříme tzv.kartáč na ose y pro muže a ženy. rug(muzi, side=2) rug(zeny, side=4) ### -- Vytvoříme nadpis a podnadpis grafu. title("Srovnání hmotnosti 2 skupin", line=3) mtext("(muži a ženy)", side=3, line=1, font=2) ### -- Uložíme graf a zavřeme grafické zařízení. savePlot(filename="boxplotB", type=c("png")) dev.off()
Stonek a lodyha (stem-and-leave) Graf pojmenovaný z anglického stem-and-leave, stonek a lodyha, není klasickým grafem. Je to způsob vyhodnocení souboru dat pomocí přehledu, který ukáže rozložení celého souboru dat. ### -- Vygenerujeme soubor pseudonáhodných čísel z normálního rozložení. > x=rnorm(50, mean=0, sd=1) ### -- Zobrazíme graf. > stem(x) The decimal point is at the | -2 -1 -1 -0 -0 0 0 1 1 2 2
| | | | | | | | | | |
00 965 33310 998765 443221100 0111223444 5578889 00003 7 4 5
### -- Pomocí parametru scale nastavíme velikost intervalu. Můžeme pozorovat změnu četnosti v jednotlivých intervalech. > stem(x, scale=0.5) The decimal point is at the | -2 -1 -0 0 1 2
| | | | | |
00 96533310 998765443221100 01112234445578889 000037 45
> stem(x, scale=1) The decimal point is at the | -2 -1 -1 -0 -0 0 0 1 1 2 2
| | | | | | | | | | |
00 965 33310 998765 443221100 0111223444 5578889 00003 7 4 5
> stem(x, scale=2) The decimal point is 1 digit(s) to the left of the | -20 -18 -16 -14 -12 -10 -8 -6 -4 -2 -0
| | | | | | | | | | |
4 85 0 8 425 5 7431 22 3 9811 73952
0 2 4 6 8 10 12 14 16 18 20 22 24
| | | | | | | | | | | | |
369368 58 0571 78 141 1114 6 4
44
### -- Data, která jsme využívali v příkladu krabicového grafu. muzi=c(58, 57, 48, 73, 83, 85, 74, 65, 74, 72, 79, 81, 69, 63) zeny=c(54, 45, 59, 64, 52, 58, 56, 55, 60, 54, 50, 55, 57, 51, 68, 45, 55, 67, 64) ### -- Ukázka výstupu. > stem(muzi) The decimal point is 1 digit(s) to the right of the | 4 5 6 7 8
| | | | |
8 78 359 23449 135
> stem(zeny) The decimal point is 1 digit(s) to the right of the | 4 5 5 6 6
| | | | |
55 01244 5556789 044 78
Stripchart Stripchart je diagram, který zobrazuje rozptýlení dat v zadaném rozsahu. Podobá se vykreslení čárek na okraji grafu funkcí rug(). V příkladech uvidíme, že zobrazení dat koresponduje s krabicovým grafem, případně histogramem (dle způsobu zobrazení – parameter method="stack" a datový vektor je potřeba zaokrouhlit, v příkladu použita funkce round()).
### -- Vytvoříme 2 vektory. Použijeme stejná data jako v příkladu s krabicovým grafem. muzi=c(58, 57, 48, 73, 83, 85, 74, 65, 74, 72, 79, 81, 69, 63) zeny=c(54, 45, 59, 64, 52, 58, 56, 55, 60, 54, 50, 55, 57, 51, 68, 45, 55, 67, 64) x=rnorm(100, mean=0, sd=1) ### - Vytvoříme 5 diagramů s různým nastavením. par(mfrow=c(5,1), mar=c(4,4,1,1)) stripchart(zeny, col="red", xlab="hmotnost", xlim=c(40,90)) stripchart(list(muzi, zeny), group.names=c("muži","ženy"), ylim=c(0.5,2.5), col=c("green","red"), xlab="hmotnost", xlim=c(40,90)) stripchart(x, xlab="náhodná čísla (methoda zobrazení overplot)", method="overplot", col="blue")
stripchart(x, xlab="náhodná čísla (methoda zobrazení jitter)", method="jitter", col="darkgreen") stripchart(round(x,1), xlab="náhodná čísla (methoda zobrazení stack)", method="stack")
Pro kombinaci krabicového grafu z předchozího příkladu se stripchart diagramem můžeme použít následující kód. Výsledek vidíme na obrázku níže.
### -- Vytvoříme graf a nastavíme vlastnosti osy x a y. plot.new() plot.window(xlim=c(38,92),ylim=c(0,3), xaxs="i", yaxs="i") ### -- Vytvoříme pozadí grafu. polygon(y=c(0,3,3,0), x=c(0,0,92,92), col="yellow") ### -- Vytvoříme graf s požadovanými vlastnostmi. Hodnota atributu add=TRUE znamená, že do již otevřeného grafu přidám další, a to krabicový graf. boxplot(muzi, zeny, width=c(20,30), outline = TRUE, names=c("muži", "ženy"), xlim=c(38,92), col="grey", add=TRUE, xlab="hmotnost [kg]", horizontal=TRUE) ### -- Vytvoříme tzv.kartáč na ose y pro muže a ženy. rug(muzi, side=1)
rug(zeny, side=3) ### -- Vytvoříme nadpis a podnadpis grafu. title("Srovnání hmotnosti 2 skupin", line=3) mtext("(muži a ženy)", side=3, line=1, font=2) ### -- Vytvoříme stripchart diagram. Oblast do které vyneseme body je určena parametrem at. stripchart(list(muzi, zeny), group.names=c("muži","ženy"), ylim=c(0.5,2.5), col=c("green","red"), xlab="hmotnost", xlim=c(40,90), add=T, at=c(0.5,1.5))
Histogram Histogram je sloupcový graf, který zobrazuje rozdělení dat podle četnosti (četnost je vynesena na ose y). Hodnota osy x představuje interval hodnot, ve kterém jsou všechny hodnoty y sečteny a zprůměrovány.
x=rnorm(50, mean=0, sd=1) par(mfrow=c(2,3)) hist(x) hist(x, xlab="generovana cisla", ylab="četnost", main="histogram")
hist(x, prob=T, xlab="generovana cisla", ylab="hustota", main="histogram", col=rainbow(20)) hist(x, prob=T, breaks=c(-3,-1.5,0,1.5,3), col="blue") hist(x, prob=T, breaks=8, col=c("blue", "red")) hist(x, prob=T, breaks=10) lines(density(x), col="red")
V případě, že bychom chtěli více pracovat s grafickým zobrazením rozdělení pravděpodobnosti, nasledující graf je ukázkou jednoho z přístupů, jak do grafu vyplňovat obsah pod křivkou.
### -- Vygenerujeme sadu čísel x a jejich hustotu, kterou pak vyneseme do grafu jako křivku. x=seq(-4,4,length=1000) y=dnorm(x) plot(x, y, type="l", col="red", main="ukazka kresleni do grafu", ylab="hustota pravdepodobnosti", xlab="generována čísla") ### -- Zvolíme interval na ose x pro vykreslení oblasti pod křivkou, vytvoříme data stejně jako nahoře a vykreslíme funkci polygon(). x=seq(-3,-2,length=1000) y=dnorm(x) polygon(c(-3,x,-2), c(0,y,0),col="blue") x=seq(-2,-1,length=1000) y=dnorm(x) polygon(c(-2,x,-1), c(0,y,0),col="red") x=seq(-1,1,length=1000)
y=dnorm(x) polygon(c(-1,x,1), c(0,y,0),col="gray")
Možnosti koláčového grafu Známý, jednoduchý a přitom často využívaný graf je koláčový, kruhový nebo segmentový graf. Zobrazuje kvantitativní informace celého souboru dat. Data se rozdělí na jednotlivé segmenty v závislosti na jejich vlastnostech. Celý kruh představuje celý soubor dat, velikost segmentů je relativní k celé ploše kruhu. Pro tvorbu koláčového grafu existuje jednoduchá funkce pie(), která vytvoří 2D koláčový graf. Pro zajímavější grafický efekt lze použít funkci pie3D(). Ta je ale součástí knihovny plotrix, kterou musíme doinstalovat. Skript proto obsahuje i postup instalace knihovny a její načtení. Ukázka 2D koláčového grafu.
Ukazka 3D koláčového grafu. Obrázek je výsledkem následujícího skriptu.
### -- Protože jsem data kopiroval z tabulky MS Excel, po nakopírování z tabulky pomocí funkce readClipboard jsem získal tyto textove vektory. muzi=c("32,00", "43,00", "16,00", "9,00") zeny=c("55,00", "65,00", "64,00", "16,00") barva.vlasu=c("černá", "hnědá", "blond", "zrzavá") muzi; zeny; barva.vlasu ### -- Nahradíme v nich čárku za tečku. for (i in 1:length(muzi)) { muzi[i] = sub(",", ".", muzi[i]) zeny[i] = sub(",", ".", zeny[i]) } ### -- Převedeme na číslo. muzi = as.numeric(muzi) zeny = as.numeric(zeny) muzi; zeny; barva.vlasu ### -- Přiřadíme jména prvkům vektoru, aby se správně vypsal název prvků v grafu. U grafu s vektorem ženy budou v popiscích pouze čísla. names(muzi)=barva.vlasu muzi
### -- Nastavíme grafické rozhraní a vytvoříme první 2 grafy. par(mfrow=c(2,2), mar=c(1,1,1,1)) pie(muzi, xlab="text", main="muži - nadpis grafu", col=colours()[10:14], density=c(5, 10, 15, 25), angle=c(30,-30, 90, 120)) mtext("možný popisek grafu", side=1, line=-1) pie(zeny, xlab="text", main="ženy - nadpis grafu", col=colours()[20:24]) mtext("možný popisek grafu", side=1, line=-1) ### -- Přidáme další 2 grafy s upraveným nastavením. pie(muzi, xlab="text", main="muži - nadpis grafu", col=colours()[30:34], density=c(5, 10, 15, 25), angle=c(30,-30, 90, 120), clockwise=TRUE) mtext("(možný popisek grafu)", side=1, line=-1) pie(zeny, xlab="text", main="ženy - nadpis grafu", col=colours()[50:54], clockwise=TRUE) mtext("(možný popisek grafu)", side=1, line=-1)
### -- Pro 3D koláčový graf potřebujeme nainstalovat balíček plotrix. install.packages("plotrix") ### -- Vybereme server, ze kterého stáhneme balíček (kterýkoliv).
### -- Vidíme hlášení o instalaci. > install.packages("plotrix") --- Please select a CRAN mirror for use in this session --package 'plotrix' successfully unpacked and MD5 sums checked The downloaded binary packages are in
C:\Users\admin\AppData\Local\Temp\RtmpgvlxIW\downloaded_ packages ### -- Pokračuje kód z editoru. library("plotrix") ### -- Vytvoříme 6 různých grafů, které se budou lišit nastavením. Více v nápovědě k funkci pie3D(), ?pie3D(). windows(8,5) par(mfrow=c(2,3), mar=c(0,0,0,0)) pie3D(muzi) box() pie3D(muzi, labels=barva.vlasu, height=0.3, radius=0.2) box() pie3D(muzi, labels=barva.vlasu, height=0.3, radius=0.6) box() pie3D(muzi, labels=barva.vlasu, labelcex=0.8) box() pie3D(muzi, main="muži - nadpis grafu", labels=barva.vlasu, col=colours()[10:14], labelcex=0.8, explode=0.05) box() pie3D(muzi, main="muži - nadpis grafu", labels=barva.vlasu, col=colours()[10:14], labelcex=0.8, explode=0.05, radius=0.8) box()
Úvod k programu SigmaPlot Program SigmaPlot je komerční profesionální software od společnosti Systat Software, Inc. Práce s programem není nijak složitá. Vzhledem připomíná tabulkový procesor MS Excel. Jedinou nevýhodou pro práci je cizojazyčnost. Program „mluví“ pouze anglicky. To je ale nevýhoda všech podobných programů. Důvodem je pravděpodobně cílová skupina uživatelů, u které se předpokládá alespoň základní znalost anglického jazyka. Aktuální verze programu SigmaPlot je 12.5. Je určena pro prostředí operačního systému MS Windows 2000, MS Windows NT 4.0 SP6, MS Windows XP nebo MS Windows. 30-ti denní plná verze pogramu je k dispozici na adrese http://www.sigmaplot.com, a to po předcházející registraci. Všechny instrukce ke stáhnutí, instalaci a dalším požadavkům týkajících se chodu programu jsou dostupné na výše uvedených stránkach výrobce. Upravené rozhraní programu je znázorněné níže.
Panely nástrojů (na obrázku jsou přeházené).
Co je to notebook, notebook manager a základní informace pro práci s programem Soubory vytvářené programem SigmaPlot se nazývají notebooky. Notebook obsahuje všechna data, grafy, popisky, případně reporty vytvořené statistickými funkcemi. Pro práci s notebookem slouží Notebook manager, který může být zadokován v levé části programu nebo zobrazen v plovoucím okně. Vždy zobrazuje jména všech otevřených notebooků včetně jejich součástí. Souhrnné informace o notebooku se zobrazí kliknutím na View summary information v Notebook manageru.
Notebook vytvoříme v nabídce File > New a ukládáme v nabídce File > Save as. Notebook může být chráněn heslem, které se nastaví v nabídce Tools > Password. Každý notebook může obsahovat jednu nebo více sekcí. Každá sekce může obsahovat jeden Pracovní sešit nebo sešit programu Excel a více položek, kterými jsou Grafy, Reporty, Rovnice, Sekce, Makra, Transformace. Pro vytvoření nové sekce klikneme pravým tlačítkem na vybraný notebook a vybereme New > Section. Pro vytvoření nové položky v sekci postupujeme
stejným způsobem, ale místo Section vybereme požadovanou položku. Vytvořené sekce a položky v sekcích se mohou v rámci jednoho nebo mezi více notebooky různě kopírovat, přejmenovávat a mazat nebo také tisknout. Vlastnosti položek v sekcích se nastavují v nabídce Tools > Options. Různé vlastnosti nastavujeme v různých záložkách. Obecné nastavení programu nalezneme v záložce General.
Asi nejdůležitější částí notebooku je pracovní sešit, protože obsahuje data, se kterými se pracuje. Pracuje se s ním podobně jako s pracovním sešitem v programu MS Excel. Umožňuje nastavovat šířku řádků, sloupců, nastavovat jejich pojmenování, vkládat řádky a sloupce. Vkládání dat je možné ručně, kopírováním a vkládáním (pozor, vkládání je možné v modu Insertion – buňky se posunou nebo Overwrite – buňky se přepíšou) nebo pomocí importu z jiných souborů. Základní globální nastavení pracovního sešitu nalezneme v nabídce Tools > Options… a jednotlivé buňky můžeme formátovat v nabídce Format > Cells… SigmaPlot obsahuje velké množství podporovaných souborů pro import. Postup importu se svým průběhem podobá možnostem jiných programů, jako například programu MS Excel. Po otevření importovaného souboru je potřeba
zvolit oddělovač dat, aby se data správně vložila do připravené tabulky. Příklad importu textového souboru:
Data je možné exportovat do mnoha formátů. Příklad exportovaných dat do souboru TXT:
Zajímavou možností je prohlížení základních parametrů popisné statistiky, která se automaticky vloží do nového pracovního sešitu. Tato statistika se zobrazí po volbě nabídky View > Statistics. Zpracovaná statistika se zobrazí v novém pracovním sešitu, který se neukládá, ale data z něj se mohou kopírovat a dále zpracovávat.
Data z pracovního sešitu můžeme kdykoliv vytisknout z nabídky File > Print. V nastavení upravíme požadované volby a tlačítkem Setup… můžeme ještě vybrat tiskárnu, na které chceme tisknout, a nastavit její vlastnosti podobně jako v jiných programech.
Tvorba grafů Základní nastavení stránky s grafem najdeme v nabídce Tools > Options v záložce Graph. Toto nastavení je omezené a vlastnosti grafu je možné dále modifikovat po vytvoření grafu v průvodci grafu, tzv. Graph Wizard. Ten se aktivuje výběrem grafu, kliknutím na graf pravým tlačítkem a výběrem volby
Graph Properties. Pro vytváření grafů je velmi důležité naučit se způsob uspořádání dat v pracovním sešitu. Každý graf má své vlastní nároky na uspořádání dat. Grafy v Sigmaplotu jsou vždy vytvořeny z dat umístěných ve sloupcích nebo řádcích. Proto je potřeba data uspořádat tak, aby bylo možné pomocí průvodce tvorby grafu určit (vybrat) část dat, kterou chceme zpracovat. Například pro koláčový graf se data umístí do jednoho sloupce. V případě zpracování kategoriálních dat je možné kategorie umístit do jednoho sloupce a korespondující naměřené hodnoty do sloupců následujících. V případě jednoduché křivky umístíme data pro x osu do samostatného sloupce a pro y osu do jiného sloupce. V případě, že nejsou ve sloupcích korespondující hodnoty (hodnoty jsou vynechány), budou tyto buňky ignorovány. Pokud chceme vynést více křivek do jednoho grafu, vložíme data pro každou křivku do sloupců vedle sebe, data pro osu x do jednoho sloupce a korespondující hodnoty y vložíme do sloupců následujících vedle sebe. Program SigmaPlot obsahuje velké množství typů grafů. Každý z nich má mnoho volitelných stylů. Úprava již vytvořených grafů včetně typu a stylu je možná i po jeho vytvoření, a to pomocí průvodce tvorby grafu. Ze 2D grafů je možné zmínit bodový, spojnicový, bodový a spojnicový, plošný, paprskový, tzv. box plot, ternary plot nebo výsečový graf. Z 3D grafů lze vybírat mezi obrysovým, bodovým, spojnicovým, tzv. mesh plot nebo sloupcovým diagramem. Nejjednodušší vytvoření grafu je pomocí průvodce tvorby grafu z nabídky Graph > Create Graph. Tímto způsobem velmi jednoduše vytvoříme graf v několika krocích. Veškeré vlastnosti následně upravujeme pomocí editoru vlastností Graph properties. Průvodce vytvoření grafu má několik kroků, i) Vyběr typu grafu, ii) Vyběr stylu grafu, iii) Výběr uspořádání dat pro graf, iv) Výběr sloupců nebo řádků, ze kterých se graf vytvoří, v) posledním krokem je kliknutí na tlačítko Finish. Graf se vytvoří jako nová položka pracovní sekce s názvem Graph. Je to stránka s grafem, do které můžeme vkládat další grafy a stránku různým způsobem formátovat. Tato stránka slouží k zobrazování grafů, jejichž data jsou umístěna v pracovním sešitu dané sekce. V případě vytvoření nové stránky s grafem se nová stránka vždy asociuje s pracovním sešitem v dané sekci. Stránky mohou obsahovat grafy, text nebo jiné objekty. Vlastnosti stránky je možné nastavit na dvou místech, a to v nabídce Tools > Options na záložce Page, v nabídce File > Page Setup. Do stránky je možné vkládat neomezené množství grafů a objektů. Nové objekty vytváříme pomocí toolbaru Stránka. Objekty je pak možné různě seskupovat a nastavovat jejich vlastnosti.
Graf patří k objektům stránky. Více grafů je možné uspořádat na stránce pomocí Format > Arrange Graphs… Úpravu již vytvořeného grafu provádíme v okně Graph Properties.
V případě, že chceme změnit typ grafu, styl, přidat data, použijeme průvodce grafu Graph Wizard.
Do již vytvořeného grafu můžeme vkládat další diagramy, a to i diagramy grafů jiných typů. Pravým tlačítkem klikneme na graf a vybereme z nabídky Add plot… Tyto další diagramy mohou být zobrazené nebo skryté a samozřejmě je můžeme kdykoliv vymazat.
Ak máme mnoho hodnot, které vynášíme do grafu, můžeme do něj vynést pouze vybrané, a to v zadaném rozsahu. Zajímavou volbou je možnost ignorovat chybějící hodnoty dat nebo hodnoty mimo rozsah os (funguje to hlavně u spojnicových grafů). Pro symboly grafů můžeme nechat vybrat definovaný text a dokonce velikost symbolů, který se vkládá do sloupce následujícího v pracovním sešitu. Na grafech je možné zvýraznit tzv. padající čáry (Drop Lines). V případě, že chceme na spojnici zvýraznit některé místo, vložíme do grafu další diagram a jen jeden bod s vlastností symbolu none a zvýrazníme padající čáry dle potřeby. Anglickým výrazem outliers označujeme hodnoty zpracovávaných dat, které po vynesení do grafu leží mimo oblast, kde je kumulována většina dat. Tyto hodnoty mohou do vysoké míry narušovat spolehlivost statistického zpracování. Nejčastěji jsou to data naměřená nepřesně, případně data s určitými anomáliemi. Často proto není vhodné zahrnovat tato data do statistik a grafů. Můžeme je velmi rychle a efektivně vyřadit ze zpracovávaného souboru dat a to tak, že vytvoříme graf s celým souborem získaných dat. Označíme postupným dvojitým kliknutím bod, který chceme vyloučit ze zpracování. Po návratu do pracovního sešitu se buňky, které obsahují data pro označený bod, zobrazí barevně. Tyto buňky přemístíme vedle nebo jednoduše v nabídce Format > Cell... vybereme textový formát buněk. Takto upravená data se vyřadí z grafu a ze statistického zpracování.
Vytváření grafů z definovaných rovnic, vkládaní lineárních a polynomiálních regresí do grafů, tvorba histogramů Program Sigmaplot umožňuje vytvářet grafy z předem definovaných rovnic. Tato vlastnost může být velmi užitečná v případě hledání matematického řešení pro naše data nebo pro hledání parametrů matematických modelů, se kterými se sesbíraná data mohou srovnávat. Samozřejmě tyto volby je možné použít i k jiným účelum, a to například k přípravě demonstračních grafů apod. K dispozici je kolem 100 předdefinovaných funkcí. Uživatel může také sám vytvářet vlastní funkce a vytvářet z nich grafy, případně je vkládat do již vytvořených grafů. Při vytváření grafů z předdefinovaných nebo námi definovaných rovnic volíme menu Graph > Plot Equation. Na záložce Equation můžeme vytvářet vlastní rovnice. Hodnoty parametrů rovnic zapisujeme na záložce Options. Na záložce Library můžeme volit předdefinované rovnice a záložka Solve slouží jako řešitel. Záložka Solve umožňuje řešit rovnice, ale pouze pro jednu
nezávislou proměnnou a vypočítat hodnotu funkce pro proměnnou dané funkce.
Pro počítání lineárních a polynomiálních regresí ze sesbíraných dat a jejich vkládaní do grafů obsahuje SigmaPlot nabídku Graph > Linear Regression... Výsledek výpočtu je možné prohlížet, kopírovat, případně z něj vytvářet reporty. Do grafů je možné vkládat také intervaly spolehlivosti a predikční interval z vypočtených regresí. Samozřejmostí je vkládání refenčních čar jako například průměr, směrodatná odchylka apod. Součástí programu Sigmaplot je i funkce Histogram. Pomocí průvodce histogramem, který se spustí zvolením nabídky Graph > Histogram, můžeme automaticky vytvářet histogramy, a to i s definováním počtu kategorií pro konkrétní data. V případě, že chceme vytvořit vlastní kategorie, můžeme použít
nabídku Transform > User-Defined, kde použijeme funkce pro vytváření histogramu. Připravená data např. ve sloupci 1 a kategorie ve sloupci 10 budou na zakladě výrazu „col(11)=histogram(col(1);col(10))“ uspořádána do sloupce 11.
Report editor V sekci můžeme vytvořit stránku s textovým editorem. Jmenuje se Report editor a slouží k vytváření poznámek a anotací zpracovávaných dat a je velmi vhodným pomocníkem při dokumentaci zpracování. Je to vlastně jednoduchý textový editor s možností vkládaní OLE2 objektů. Do Report editoru jsou exportovány i některé výstupy statistického zpracování. Vlastnosti tohoto editoru můžeme upravit v nabídce Tools > Options > záložka Report.
Report vytvoříme kliknutím pravého tlačítka na vybranou sekci v notebooku a výběrem z nabídky New > Report. Vlastnosti stránky nastavíme v nabídce File > Page Setup. Report editor umožňuje jednoduché formátování jak textu,
tak tabelátorů z nabídky Format > Tabs
nebo celých odstavců.
Stránky z Report editoru je možné exportovat do RTF, HTML nebo PDF souborů, a to z nabídky File > Export, nebo je můžeme tisknout z nabídky File > Print.
Příprava publikovatelných výstupů SigmaPlot umožňuje kromě jiného zpracovat data a připravit je do výstupů v podobě HTML exportů, tedy pro publikování přímo na webu. Program umožňuje připravit grafy podle různých požadavků vydavatelstev, které se liší ve výstupních formátech a tištěné kvalitě grafů nebo v parametrech jako velikosti a typu textu, šířku čar grafů apod. Součástí programu je volba pro Submission Assistant. Tento průvodce umožňuje automatickou kontrolu nastavených vlastností exportovaných výstupů. Submision Assistant je plně konfigurovatelný a je možné s ním připravit vlastní šablony.
Doporučené studijní zdroje Venables, W. et all. An introduction to R notes on R, a programming environment for data analysis and graphics. *online+. Dept. of Statistics and Mathematics, Wirtschaftsuniversit t Wien, 2008. Dostupné z: Murrell, P. R Graphics, Second Edition. Chapman & Hall/CRC, 2011 Verzani, J. simpleR – Using R for Introductory Statistics. *online+. Dostupné z: Drozd, P. Cvičení z biostatistiky. Základy práce se softwarem R. *online+. Dostupné z: Mittal, H. R Graph Cookbook. Packt Publishing, 2011 Dokumentace k programu SigmaPlot 11, SigmaPlot 11 Users Guide Part 1 – User s Guide. Dokumentace k programu SigmaPlot 11, SigmaPlot 11 Users Guide Part 2 – Statistics. Lepš, J. Biostatistika, Universitas Bohemiae Meridionalis, České Budějovice, 1996 Zvára, K. Biostatistika, Karolinum, Praha 1998 Zvárová J. Základy statistiky pro biomedicínské obory. [online]. Dostupné z: McDonald, J. Handbook of Biological Statistics. [online]. Dostupné z:
Vybrané internetové zdroje http://www.r-project.org http://www.statmethods.net http://www.sr.bham.ac.uk/~ajrs/R http://www.cookbook-r.com http://msenux.redwoods.edu/math/R http://ww2.coastal.edu/kingw/statistics/R-tutorials/singlesample.html
http://www.stat.columbia.edu/~martin/W2024/R2.pdf http://statistics.berkeley.edu/computing/r-t-tests http://msenux.redwoods.edu/math/R/StandardNormal.php
