Adiciona conteudo introdutoorio.

parent 5b65a6c5
......@@ -23,6 +23,14 @@ navbar:
- icon: fa-television
text: "Material"
menu:
- text: "Introdução ao R"
href: tutorials/00-intro-R.html
- text: "Operações com objetos"
href: tutorials/00-objects.html
- text: "Visualização básica com R"
href: tutorials/00-vis-graphics.html
- text: "Visualização com a lattice"
href: tutorials/00-vis-lattice.html
- text: "Manipulação e visualização"
href: tutorials/00-datatable-ggplot2.html
- text: "Validação cruzada"
......
---
title: "Introdução ao R"
subtitle: "Instalação e artimética básica"
author: Prof. Walmes M. Zeviani
date: '`r Sys.Date()`'
#bibliography: ../config/Refs.bib
#csl: ../config/ABNT-UFPR-2011-Mendeley.csl
---
```{r, include = FALSE}
source("../config/setup.R")
opts_chunk$set(
cache = FALSE,
message = FALSE,
warning = FALSE)
```
# Introdução ao ambiente R
****
# Download e instalação do R
* Download do R: <http://cran.r-project.org/>.
* Download do RStudio: <http://www.rstudio.com/products/RStudio/>.
* Download do Emacs+ESS:
* usuários Windows <http://vgoulet.act.ulaval.ca/en/emacs/>.
* usuários Linux instalam por `sudo apt-get install emacs ess`.
* Download do Tinn-R (para Windows apenas):
<http://sourceforge.net/projects/tinn-r/>.
* Outros editores:
* [Wikipedia - R programming language editors](http://en.wikipedia.org/wiki/R_%28programming_language%29#Editors_and_IDEs)
* [Sciviews - Editors](http://www.sciviews.org/_rgui/projects/Editors.html)
****
# Primeiros passos
Abra o R instalado em seu sistema para iniciar uma sessão.
```{r, eval=FALSE}
# Texto após o sinal de hash não é interpretado, serve de comentário.
2 + 6 + 5 + 9 + 3 + 2 # Comentário pode ser após alguma instrução.
# Uma intrução pode ser dividida em duas linhas.
2 + 6 + 5 +
9 + 3 + 2
# E em uma linha podem existir mais de uma instrução.
2 + 6; 14 + 12; 40 - 23
```
****
# Objetos
Em um curso introdutório aborda-se os 4 tipos básicos de objetos para
armazenamento de dados no R: vetores, arranjos, tabelas (data.frames) e
listas. Em resumo, distinguem-se tais objetos pela **forma** na qual
armazenam dados.
* vetor: tem apenas uma dimensão que é o comprimento (número de
elementos) e armazena valores de apenas um tipo (ex. só números
inteiros).
* arranjo (array): é uma extensão de vetor que permite mais de uma dimensão. Só
permite um tipo de valor. No caso de ter duas dimensões (linha e
coluna) chamamos os arranjos de matrizes.
* tabela: no idioma R são mais conhecidos por *data frames*. Têm duas
dimensões (linha e coluna). Cada coluna é como se fosse um vetor e
por isso pode ter tipo de conteúdo diferente das demais
colunas. Todas as colunas têm o mesmo comprimento (que é o que
permite acomodar no formato de tabela).
* lista: é um tipo de objeto cuja unidade básica é o item da
lista. O "tamanho" da lista é o número de elementos/itens que
possui. Cada elemento, no entanto, pode ser um objeto de qualquer
classe mecionada acima. O *data frame* é uma lista especial na qual
cada item é um vetor (ou matriz) de mesmo número de elementos
(linhas).
Nos objetos é importante conhecer formas de selecionar os valores dentro
do objeto. Além disso, conhecer os atributos e saber modificá-los é
interessante principalmente porque gráficos e procedimentos sobre tais
objetos dependem dos seus atributos propriedades. As formas de
selecionar elementos de um objeto são com os operadores:
* `[]`, `[ , ]`, `[ , , ]`: para vetores e arranjos. As virgulas
servem para especificar à dimensão que recebe seleção. Serve para
selecionar listas e *data frames* também.
* `$`: para listas e *data frames* (pois DF é um caso de lista).
* `[[]]`: serve para listas.
* `@`: serve para listas de objetos classe S4.
A seleção de elementos/linhas/colunas/itens nos objetos pode ser de 4
formas:
* Pelo índice: número inteiro correspondente à sua posição.
* Por um vetor lógico: valores `TRUE` vão selecionar os elementos
correspondentes.
* Pelo nome: quando o elemento possui nome.
Abaixo são ilustrados os 4 tipos básicos, atributos e seleção.
```{r}
#-----------------------------------------------------------------------
# Vetor.
x <- 100:105
# Atributos.
class(x)
mode(x)
typeof(x)
length(x)
str(x)
attributes(x)
dput(x)
is.vector(x)
is.numeric(x)
is.integer(x)
x[3:5]
x[-2]
x[c(2, 3)]
#-----------------------------------------------------------------------
# Vetor nomeado.
x <- c(Paulo = 7.8, Ulisses = 9, Ricardo = 8.5, Lincon = 4.5,
Thobias = 7.1)
# Atributos.
class(x)
mode(x)
typeof(x)
length(x)
str(x)
attributes(x)
dput(x)
is.vector(x)
is.numeric(x)
is.integer(x)
x[3:5]
x[-2]
x[c(2, 3)]
x["Ulisses"]
x[c("Ricardo", "Thobias")]
#-----------------------------------------------------------------------
# Um arranjo de duas dimensões.
X <- matrix(1:9, nrow = 3, ncol = 3)
class(X)
mode(X)
typeof(X)
dim(X) # ncol(X) e nrow(X).
str(X)
attributes(X)
dput(X)
is.matrix(X)
is.array(X)
is.numeric(X)
is.integer(X)
X[1, ]
X[1:2, ]
X[-2, ]
X[, -2]
X[, c(3, 2, 1)]
X[3:1, c(3, 2, 1)]
#-----------------------------------------------------------------------
# Um arranjo de 3 dimensões (cúbico).
X <- array(1:24, dim = c(3, 4, 2))
class(X)
mode(X)
typeof(X)
dim(X) # ncol(X) e nrow(X).
str(X)
attributes(X)
dput(X)
is.matrix(X)
is.array(X)
is.numeric(X)
is.integer(X)
X
X[1, , ]
X[, 1, ]
X[, , 1]
#-----------------------------------------------------------------------
# Um data frame.
da <- data.frame(id = 1:5,
aluno = c("Júlio", "Ana", "Pietra", "Bianca", "Nelson"),
nota = c(9, 8.5, 7.1, 9.8, 8),
falta = c(12, 4, 4, 0, 2))
class(da)
mode(da)
typeof(da)
dim(da) # ncol(da) e nrow(da).
str(da)
attributes(da)
dput(da)
is.data.frame(da)
is.list(da)
da[1, ]
da[, 2]
da[, "aluno"]
da[, c("nota", "falta")]
da[1:3, c("nota", "falta")]
#-----------------------------------------------------------------------
# Uma lista.
L <- list(item1 = x, item2 = X, item3 = da)
class(L)
mode(L)
typeof(L)
length(L)
str(L)
attributes(L)
dput(L)
is.data.frame(L)
is.list(L)
L$item1
L$item3[, "aluno"]
L[-2]
L[["item1"]]
L[[1]]
```
****
# Regras lógicas
É muito frequênte a necessidade de selecionar elementos de um objeto de
acordo com alguma regra lógica. No objeto `da`, por exemplo, quais os
alunos com mais de 10 faltas? Quantos alunos nota superior à 9?
Para responder à essas perguntam tem-se que utilizar regras lógicas. As
regras lógicas podem ser simples ou compostas. Os operadores para regras
lógicas são `< > <= >= == !=`. Os operadores para fazer regras compostas
são o E `&` e o OU `|`. E o operador `%in%` é usado para representar o
operador pertence para conjuntos. O resultado de uma regra lógica é um
vetor lógico que no caso será usando para seleção. São operadores também
úteis o "todos" `all()` e "algum" `any()`.
```{r}
# Selecionando as notas maiores que 8.
sel <- da$nota > 8
sel
da[sel, ]
# Selecionando as notas maiores que 8 com faltas não superior à 10.
sel <- da$nota > 8 & da$falta <= 10
sel
da[sel, ]
# O operador ! inverte um vetor lógico.
!sel
da[!sel, ]
da$nota > 8 & da$falta <= 10
# da$nota>8 && da$falta<=10 # **verificar!
sel <- da$aluno %in% c("Ana", "Bianca")
# sel <- is.element(da$aluno, c("Ana", "Bianca"))
da[sel, ]
all(da$nota > 7)
any(da$falta < 10)
sum(da$nota > 8)
```
****
# Conversão
As conversões podem ser de *formato* ou de *tipo de conteúdo*. Pode-se
precisar converter um *data frame* em uma matriz para, por exemplo,
fazer uma análise de componentes principais bem como converter um vetor
de characteres para fator para mudar a ordem ou rótulo de seus
níveis. As funções para conversão iniciam com o padrão `as.*`.
```{r}
# As funções para conversão.
apropos("^as\\.")
# De numérico para inteiro.
x <- seq(from = 1, to = 12, by = 2)
x
# c(1, 3, 4)
# c(1L, 3L, 4L)
is.integer(x)
object.size(x)
dput(x)
x <- as.integer(x)
object.size(x)
dput(x)
# De data.frame para lista.
as.list(da)
# De vetor para matriz.
as.matrix(x)
```
Dentre os tipos de conversão deve-se destacar a importância daquela que
envolve characteres e fatores. Muitos dos métodos de análise de dados,
das tabelas de frequência até análise de variância são desenvolvidos
para dados do tipo fator.
```{r}
# Um vetor com 3 níveis.
x <- sample(c("bom", "regular", "ruim"), size = 10, replace = TRUE)
# Atributos.
class(x)
mode(x)
typeof(x)
length(x)
str(x)
attributes(x)
dput(x)
is.vector(x)
is.character(x)
is.factor(x)
# Conversão.
x <- as.factor(x)
# Atributos.
class(x)
mode(x)
typeof(x)
length(x)
str(x)
attributes(x)
dput(x)
is.vector(x)
is.character(x)
is.factor(x)
levels(x)
nlevels(x)
```
****
# Informações da sessão
Consultar e fornecer as informações da sessão é algo útil para ter
conhecimento da versão do R e seus pacotes bem como detalhes do sistema
operacional. Dessa forma pode-se verificar se a atual instalação está
defasada, por exemplo. Usuários Linux que fazer instalação do R pelo
repositório debian estão sempre com a versão mais recente do R.
```{r, eval=FALSE}
# Lista os objetos existentes.
ls()
# Remove objetos existentes.
rm(list = c("da", "L"))
# Mostra informações da sessão, versões e pacotes.
sessionInfo()
# Mais informações.
cbind(Sys.info())
# Salva a imagem (objetos criados) para serem carregados no
# futuro ou compartilhados.
save.image("minhaprimeirasessao.RData")
rm(list = ls())
ls()
# Carrega sessão.
load("minhaprimeirasessao.RData")
ls()
# Mostra o diretório de trabalho.
getwd()
# setwd()
# Mostra os arquivos dentro no diretório.
list.files()
```
****
# Instalar pacotes oficiais
Os pacotes oficiais para o R são disponibilizados pelo
[cran.r-project.org](http://cran.r-project.org/).
```{r, eval=FALSE}
# Instala um pacote.
install.packages("plyr",
dependencies = TRUE,
repos = "http://cran-r.c3sl.ufpr.br/")
# Instala vários.
install.packages(c("plyr",
"doBy",
"multcomp",
"latticeExtra",
"devtools"),
dependencies = TRUE,
repos = "http://cran-r.c3sl.ufpr.br/")
# Faz requisição do pacote.
library(plyr)
library(multcomp)
```
****
# Instalar pacotes do GitHub
Muitos desenvolvedores de pacotes R têm utilizado o GitHub para manter
seus projetos e fazer colaboração em código. O pacote
[knitr](https://github.com/yihui/knitr) e o
[plyr](https://github.com/hadley/plyr) são exemplos de pacotes R
mantidos no GitHub.
```{r, eval=FALSE}
# Pacote wzRfun por Walmes Zeviani.
browseURL("https://github.com/walmes/wzRfun")
library(devtools)
install_github("wzRfun", "walmes")
```
****
```{r, message=FALSE, error=FALSE, warning=FALSE}
#-----------------------------------------------------------------------
# Versões dos pacotes e data do documento.
devtools::session_info()
Sys.time()
```
---
title: "Introdução ao R"
subtitle: "Programação orientada a objetos"
author: Prof. Walmes M. Zeviani
date: '`r Sys.Date()`'
#bibliography: ../config/Refs.bib
#csl: ../config/ABNT-UFPR-2011-Mendeley.csl
---
```{r, include = FALSE}
source("../config/setup.R")
opts_chunk$set(cache = FALSE,
message = FALSE,
warning = FALSE)
```
****
# Sequências, repetições e grides
```{r}
#-----------------------------------------------------------------------
# Sequências regulares.
1:5
2 * (1:5) - 1
3 * (1:5) - 2
x <- seq(from = 1, to = 12, by = 2)
x
x <- seq(from = 1, to = 12, length.out = 5)
x
x <- seq(from = 1, by = 3, length.out = 5)
x
x <- seq(to = 20, by = 3, length.out = 6)
x
#-----------------------------------------------------------------------
# Repetições regulares.
x <- rep(1, times = 5)
x
x <- rep(1:3, times = 3)
x
x <- rep(1:3, each = 3)
x
#-----------------------------------------------------------------------
# Grides.
da <- expand.grid(vari = c("Carmen", "Lucia", "Teresa"),
bloco = gl(3, 1),
nitro = seq(0, 100, by = 20))
da
str(da)
da <- expand.grid(trat = c("tratado", "controle"),
bloco = c("I", "II", "III"))
da
```
****
# Números aleatórios
```{r}
#-----------------------------------------------------------------------
# Números uniformes.
x <- runif(10)
x
#-----------------------------------------------------------------------
# Números da distribuição normal padrão.
x <- rnorm(10, mean = 0, sd = 1)
# curve(dnorm(x, 0, 1), -4, 4)
# rug(x)
#-----------------------------------------------------------------------
# Amostra aleatória de população discreta finita com e sem reposição.
u <- c("Superman",
"Batman",
"Aquaman",
"Flash",
"Green Lantern")
sample(u, size = 3)
u <- c("Iron Man",
"Thor",
"Captain America",
"Hulk",
"Black Widow",
"Hawkeye")
sample(u, size = 10, replace = TRUE)
```
****
# Ordenar, inverter e aleatorizar
```{r}
#-----------------------------------------------------------------------
# Um vetor com número uniformes.
x <- runif(6)
# As posições do menor para o maior valor.
order(x)
# O vetor ordenado do menor para o maior.
sort(x, decreasing = FALSE)
x[order(x)]
# Os valores em ordem inversa.
rev(x)
# Ordenando um vetor por valores em outro.
u <- c("Iron Man",
"Thor",
"Captain America",
"Hulk",
"Black Widow",
"Hawkeye")
u[order(x)]
# O vetor com os elementos aleatorizados.
sample(u)
```
****
# Estatísticas simples
```{r}
#-----------------------------------------------------------------------
# Um vetor com dados de precipitação.
precip
x <- precip
sum(x)
mean(x)
median(x)
min(x)
max(x)
range(x)
fivenum(x)
IQR(x)
quantile(x, probs = c(0.05, 0.95))
var(x)
sd(x)
mad(x)
diff(range(x))
100 * sd(x)/mean(x)
library(fBasics)
skewness(x)
kurtosis(x)
library(EnvStats)
# Algumas funções são substituídas.
skewness(x)
kurtosis(x)
cv(x)
summaryStats(x)
sx <- summaryFull(x)
sx
str(sx)
sx["10% Trimmed Mean", ]
```
****
# Família apply
A família `*apply` e agregados representa um conjunto de funções
destinadas à tarefas por estrato e/ou margem (índice). Tarefas assim
foram recentemente batizadas de SAC (*split-apply-combine*). São essas
funções do pacote básico do R que permiter obter médias por tratamento,
coeficientes de variação por resposta (por coluna). Isoladamente cada
uma