02-basicr.Rmd

# R! {#r}

A linguagem R pode ser usada desde uma simples calculadora até uma poderosa ferramenta estatística, seja para análise de dados, seja para machine learning.

Nesse capítulo veremos o básico da linguagem. Como a ideia é cobrir o máximo de conteúdo possível, passaremos bem rápido pelos conceitos básicos, com alguns exercícios para melhor entendimento.

## Variáveis Básicas

Podemos armazenar valores, strings ou operadores lógicos nas chamadas variáveis básicas. É com elas que podemos fazer operações básicas e transformar o RStudio em uma calculadora superpoderosa. Existem 5 tipos de variáveis básicas, sendo elas:

- Numeric (`r 1`): valores numéricos com ou sem casa decimal
```{r}
5+2.3
pi
```
- *Character* (`r "a"`): com eles podemos armazenar strings, como o título de um gráfico
```{r}
titulo <- "Isso é uma string"
titulo
```
- *Integer* (`r 1`): são valores inteiros

- *Complex* (`r 1i`): também é possível armazenar valores complexos nas variáveis básicas
```{r}
3 + 4i
```

- *Logical* (`r TRUE`): são os famosos operadores Booleanos, que permitem realizar comparações entre variáveis ou dados (**Você não pode criar uma variável com os nomes TRUE ou FALSE, esses nomes são reservados pelo R**)
```{r}
1 == 2
```

## Vetores
Vetores permitem que você armazene dados em uma sequência 1D de qualquer um dos tipos listados nas variáveis básicas, mais o formato "cru" (raw) que é o modo de armazenamento de bytes. Por exemplo:

- c("A", "C", "D")
- 1:5 = c(1, 2, 3, 4, 5)
- c(TRUE, FALSE)
- c(1i, -1i)

**Importante: ao contrário do C ou do Python, na linguagem R, a contagem das posições dos vetores começa do 1 e NÃO do zero!**

## Classe

Como foi possível notar, todas as variáveis pertencem a alguma classe, dessa forma, a função `class` permite descobrir qual a classe da variável que se está utilizando:

```{r}
x <- c(1,2,3)
class(x)
```

***  
<span style="color:red">**Exercício**: Qual a classe dos seguintes vetores?</span>

`c(1, “C”, “D”)`  
`c(1, NA, “D”)`   
`c(1, NA, NaN)`  

***

## Converter objetos 
Às vezes quando trabalhamos com dados, podemos precisar "arredondar" valores ou converter vetores em listas, para isso existem algumas funções especiais.

### `as`

Um modo de forçar um objeto a assumir outra classe é por meio da função `as`:

```{r}
as.integer(c(1.5, 2.9, 1))
```

Note que a função apenas converte os números de decimais para inteiros, sem arredondar para o número mais próximo.

*** 
<span style="color:blue">**Pergunta**: O que acontece quando se tenta converter o seguinte vetor?</span>  

`as.numeric(c(1, "C", "D"))`  

***

### `merge` e `melt` {#convert_df}

Nem sempre os conjuntos de dados que você encontrar pela vida estarão no formato desejado para plotar e/ou analisar estatisticamente, dessa forma, essas duas funções poderão ajudar na sua jornada:

-  `merge`: permite a união entre dois [data frames](#dataframes), seja por colunas em comum ou linhas em comum
-  `melt`: do pacote [reshape2](https://cran.r-project.org/web/packages/reshape2/reshape2.pdf), permite que você agrupe várias colunas em função de outra coluna em comum, de acordo com o nome especificado

## Array

Ao contrário do vetor unidimensional, arrays permitem que você armazene dados em diversas dimensões, sendo todas com o mesmo comprimento.  

Vamos dar uma olhada nos argumentos da função:  

```{r}
args(array)
```

Dessa forma, é preciso "informar" ao R qual o número de dimensões que você quer no seu array:

```{r}
a <- array(data = 0, dim = c(1,1))
class(a)
```

No caso acima, como só foram desiginadas duas dimensões, o array é igual a uma matriz.

```{r}
a <- array(data = 0, dim = c(3,3,1))
class(a)
```

Como dá pra ver acima, é possível armazenar diversos elementos em um array, como por exemplo as dimensões que utilizamos no dia-a-dia de modelos numéricos: espaço (x,y,z) e tempo (z). Dessa forma, podemos criar arrays a partir de vetores e armazená-los em diverssas dimensões.

```{r}
vetor1 <- c(1,2,3,4,5)
vetor2 <- c(10,12,14,16,18,20,22,24)

a <- array(data = c(vetor1,vetor2), dim = c(3,3,2))
class(a)
```

Se você quiser, também é possível nomear as colunas e linhas do seu array:

```{r}
colunas <- c("col1", "col2", "col3")
linhas <- c("lin1", "lin2", "lin3")

array(data = c(vetor1, vetor2), dim = c(3, 3, 2), dimnames = list(linhas, colunas))
```

Além disso, sempre que precisar acessar elementos do seu array é só especificar as dimensões como para mostrar o elemento de um vetor.

```{r}
a[1,2,2] #(linha, coluna, matriz)
```

***  
<span style="color:red">**Exercício**: Crie um array com 3 dimensões, contendo três linhas e 4 quatro colunas. Acesse o elemento da segunda linha e terceira coluna desse array. Não esqueça de verificar a classe desse objeto!</span>  

***


## Matrizes e a função `matrix`

Uma matriz é um array com duas dimensões, sendo necessário informar o número de colunas e linhas, mas não o de dimensões.

Assim como em arrays, só são permitidos elementos **da mesma clase**!

Argumentos da função `matrix`:

```{r}
args(matrix)
```

Colocando dados em uma matriz:

```{r}
m1 <- matrix(data = 1:(4*4), nrow = 4, ncol = 4)
dim(m1)
```

Por padrão, a opção "byrow" é igual a **FALSE**. Quando passamos para **TRUE**, é possível organizar os dados por linha.

```{r}
m2 <- matrix(data = 1:(4*4), nrow = 4, ncol = 4, byrow = TRUE)
```

***
<span style="color:red">**Exercício**: Construa uma matriz com três linhas que contenha os números de 1 a 9.</span>

***


## Listas

Já as listas permitem que você armazene qualquer tipo de variável básica, independente da classe. Dessa forma, podemos colocar numa lista: número, caracteres, argumentos lógicos, ou que você quiser:

```{r}
list(list(list(list(1))))
```

Isso faz com que elas sejam bastante versáteis e sirvam para armazenar o que você precisar, mas elas só podem ter uma dimensão, como uma fila. Já os objetos armazenados dentro da lista não precisam ter a mesma dimensão.

```{r}
x <- list(1, "a", TRUE, 1 + 4i)
```

***  
<span style="color:red">**Exercício**: Crie uma lista contendo um vetor, uma matriz e um data frame e acesse o segundo elemento dela.</span>  

<span style="color:red">Para facilitar, já vamos te dar o data frame:</span>
```{r}
my_df <- mtcars[1:10,]
```

***


## Data Frames {#dataframes}

Os data frames são uma forma de armazenar seus dados em um formato parecido com uma planilha de excel. Você pode pensar em um data frame como uma matriz que armazena em cada coluna um dado diferente, ou como uma lista onde todos os elementos tem o mesmo comprimento.

```{r}
df <- data.frame(a = 1:3)
names(df)
class(df)
mode(df)
```

É normalmente em um data frame que você importará os seus dados e vale saber como visualizar algumas informações básicas sobre ele direto no seu console. Para isso, vamos pegar como exemplo o conjunto `mtcars` da base de dados do R:

```{r}
df <- mtcars
head(df) #mostra as sete primeiras linhas do data frame
```

Para ver as últimas linhas do data frame basta usar a função `tail`. Já uma função muito útil é a `summary`, que apresenta um "resumo" dos seus dados, como média, mediana, mínimos e máximos para cada **coluna** do data frame.

```{r}
summary(df)
```

Iremos trabalhar bastante com data frames daqui pra frente, eles se tornarão aliados muito poderosos.

## Tempo e Data

O R trabalha com três classe de tempo: `POSIXct`, `POSIXlt` e `Date`, sendo que `POSIXct` se refere ao número de segundos desde o início de 1970 no modo UTC, enquanto que `POSIXlt` armazena as datas como uma lista, contendo segundos, minutos, horas, dias, meses, etc.

```{r}
a <- ISOdate(year = 2018, month = 4, day = 5)
class(a)
b <- ISOdate(year = 2018, month = 4, day = 5, tz = "Americas/Sao_Paulo")
```

Já a classe `Date`, armazena as datas como o número de dias contados a partir de 1970.

```{r}
c <- as.Date(Sys.time())
class(c)
```

Caso você precise, o pacote [nanotime](https://github.com/eddelbuettel/nanotime) permite trabalhar com nano segundos.

Também é possível fazer sequências:

```{r}
hoje <- Sys.time()
a <- seq.POSIXt(from = hoje, by = 3600, length.out = 24)
```

Funções úteis: `weekdays`, `month` e [`julian`](https://en.wikipedia.org/wiki/Julian_day)

```{r}
weekdays(a)
months(a)
julian(a) #dia Juliano
```

O formato `POSIXct` é o mais comumente usado principalmente se os dados analisados serão plotados.


## Fatores

Os `factors` podem ser um pouco infernais. Dê uma olhada em [R INFERNO](http://www.burns-stat.com/documents/books/the-r-inferno/).  
Usados em análise estatísica, fatores são usados para armazenar variáveis categóricas, ou seja, é uma variável que pode pertencer a um número limitado de categorias, como por exemplo, dias da semana. Já uma variável contínua pode assumir um um número infinito de valores.

```{r}
a <- seq.POSIXt(from = hoje , by = 3600, length.out = 24*7)
aa <- weekdays(a)
class(aa)
```

```{r}
factor(aa)
```

São muito úteis para regressões, gráficos e resumos estatísitcos, uma vez que limita o número de possibilidades para a qual o dado pertença. Além disso, é possível estabelecer "níveis" que vão designar a categoria do seu dado.

```{r}
ab <- factor(x = aa,
             levels = c("Monday", "Tuesday",  "Wednesday",  "Thursday",
                        "Friday", "Saturday", "Sunday"))
levels(ab)
```

***  
<span style="color:red">**Exercício**: Converta o vetor abaixo em um fator e mostre os seus níveis</span>

`genero <- c("Masculino", "Masculino", "Feminino", "Masculino", "Feminino", "Feminino")`

***

Se tudo pareceu muito corrido, não se preocupe, todos esses conceitos serão praticados mais adiante!