1-O_que_e_R.Rmd

---
title: "O que é R?"
description: "Tipos de Varíaveis e Estrutura de Dados"
author:
  - name: Jose Storopoli
    url: https://scholar.google.com/citations?user=xGU7H1QAAAAJ&hl=en
    affiliation: UNINOVE
    affiliation_url: https://www.uninove.br
    orcid_id: 0000-0002-0559-5176
date: April 5, 2021
citation_url: https://storopoli.io/Linguagem-R/1-O_que_e_R.html
slug: storopoli2021oqueeR
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

<link rel="stylesheet" href="https://cdn.rawgit.com/jpswalsh/academicons/master/css/academicons.min.css"/>

Bem vindos à disciplina!

```{r welcome, echo=FALSE, fig.align='center', fig.cap='Bem-vindo!'}
knitr::include_graphics("images/bem_vindos_rtwitter.png")
```

## Conteúdos

Vamos usar todo o universo do [`{tidyverse}`](https://www.tidyverse.org)!

* Aula 1 - O que é R?
* Aula 2 e 3 — `dplyr` e manipulação de dados
* Aula 4 e 5 — `ggplot2` e visualização de dados
* Aula 6 —  Programação funcional com `purrr` e `furrr`
* Aula 7 — Regressão Linear e Regressão Logística

## Professor

[José Eduardo Storopoli (Duda)](https://storopoli.io)

## O que é R?

R vem da linguagem S que é uma linguagem estatística desenvolvida na Bell Labs na década de 1970s. E R é o "filho" *opensource* do S.

Rmarkdown é uma boa combinação de gráficos, narrativa e código. Veja o exemplo da figura abaixo.

```{r ex-plots, echo=FALSE, fig.height=3, fig.width=3, fig.cap='Exemplo de um Plot em R'}
plot(1:10, 1:10)
```

## Tipos de Variáveis do R

* `numeric`
  * `integer`
  * `double`
* `logical`
* `character`

```{r, var-types}
typeof(1L)
typeof(1.0)
typeof(TRUE)
typeof("Oi!")
is.numeric(1)
```

## Estruturas de Dados

* Mesmo tipo de variáveis:
  * 1-D: Vetores `c(...)`
  * 2-D: Matrizes `matrix()`
  * N-D: Arrays `array()`
* Tipos diferentes de variáveis:
  * 1-D: Listas `list(...)`
  * 2-D: Dataframes `data.frame(...)` ou `tibble(...)`

> OBS: Para designar podemos usar o `x = valor`, mas usamos o `<-` pois não permite equivalência ela assinala tudo que está a direita da flecha para a variável à esquerda da flecha. Ex `x <- valor` (similar ao `x := valor`). Inclusive `alt` + `-` gera um `<-` com um whitespace ao redor.

```{r vetores}
vetor_integer <- c(1L, 7L:9L)
vetor_integer
typeof(vetor_integer)
is.numeric(vetor_integer)

vetor_doubles <- c(1, 7:9)
vetor_doubles
typeof(vetor_doubles)
is.numeric(vetor_doubles)

vetor_logical <- c(TRUE, FALSE)
vetor_logical
typeof(vetor_logical)

vetor_character <- c("Oi!", "Tchau!")
vetor_character
typeof(vetor_character)
```

```{r listas}
lista_mista <- list("Oi!", TRUE, 1L)
typeof(lista_mista)

vetor_coerce <- c("Oi!", TRUE, 1L)
vetor_coerce
typeof(vetor_coerce)
```

> OBS: Named List

```{r named-list}
lista_nomeada <- list(
  "character" = "Oi!",
  "logical" = TRUE,
  "integer" = 1L
)

str(lista_nomeada)
```

### O que podemos fazer com vetores e listas?

* dimensões - `dim()`
* comprimento - `length()`
* Indexar:
  * `lista[1]` - retornará sempre uma `list`
  * `lista[[1]]` - retornará sempre um elemento
  * `lista$1` atalho para `lista[["1"]]`
  * `lista$nome` - atalho para `lista[["nome"]]`
  * `lista["nome"]` - retonará sempre uma `list`
  * `lista[["nome"]]` - retornará sempre uma `list`
* Fatiar:
  * `lista[1:30]`

```{r op-lista}
str(lista_nomeada[1])
str(lista_nomeada[[1]])
str(lista_nomeada$logical)
str(lista_nomeada[["logical"]])
str(lista_nomeada["character"])
str(lista_nomeada[1:2])
```

### `data.frames` e `tibbles`

```{r data-frames}
df <- data.frame(
  a = sample(c("A", "B"), 100, replace = TRUE),
  x = runif(100),
  y = rnorm(100),
  dia = "hoje"
)
df
```

Para solucionar a facilidade de visualização e inspeção de `data.frame`s o `{tidyverse}` possui uma estrutura de dados chamada `tibble`:

```{r tibble}
library(tibble)
convert_df <- as_tibble(df)
str(convert_df)
```

Outra vantagem do `tibble` é que eu consigo criar colunas com base em colunas "passadas". Por exemplo isso dá um erro com a função `data.frame`:

```{r df-error, eval=FALSE}
df_error <- data.frame(
  a = 1:10,
  b = a + 1
)
```

Já no `tibble` eu consigo!

```{r tibble-megapower}
tbl <- tibble(
  a = 1:10,
  b = a + 1
)
tbl_complexa <- tibble(
  idade_ano = rnorm(100, mean = 30, sd = 10),
  altura_cm = rnorm(100, mean = 165, sd = 10),
  peso_kg = rnorm(100, mean = 70, sd = 10),
  IMC = peso_kg / (altura_cm ^ 2),
  glicose = rexp(100, rate = IMC / 10)
)
tbl_complexa
```

## Vetores Especiais -- `factor`

`factor` são fatores, que para "estatísticos" é variáveis qualitativas (veja o caso da ANOVA).

`factor` é especial pq ele no fundo é um vetor de `integer` sendo que cada `integer` é uma categoria diferentes.

```{r factor}
vetor_factor <- factor(c("A", "B", "C"))
str(vetor_factor)
typeof(vetor_factor)
class(vetor_factor)
unclass(vetor_factor)
```

## Valores Especiais

* atômicos `integer`, `logical` e `character`: apenas um — `NA`
* atômicos `double`: quatro — `NA`, `NaN`, `Inf` e `-Inf`
* vetores:
  * `NA` - `logical`
  * `NA_integer_` - `integer`
  * `NA_real_` - `double`
  * `NA_character_` - `character`

## `pacote::funcao()`

Às vezes diferentes funções possuem o mesmo nome. Como que resolvemos esse conflito de *namespace*.

Simples! Nós chamamos a função com `pacote::funcao()`

Exemplo `tibble::as_tibble()`

## Ambiente

```{r sessionInfo}
sessionInfo()
```