4_TiposDeDados.Rmd

---
title: "Tipos de dados"
author: "Jônatan Tatsch"
date: "`r format(Sys.Date(), format = '%d-%m-%Y')`"
output:
  html_document:
    fig_caption: yes
    fig_width: 6
    highlight: kate
    number_sections: yes
    toc: yes
---

```{r Chunk0, comment="",prompt=FALSE, echo=FALSE, eval=TRUE, error=TRUE,highlight=TRUE,message=FALSE,warning=FALSE, results='hide'}
rm(list=ls())
# definindo globalmente tz = "GMT"
#Sys.setenv(TZ = 'GMT')
# data manipulation packages
pcks <- c("knitr", "knitcitations", "printr", "pander", "htmlTable")
invisible(sapply(pcks, require, character.only = TRUE, quietly = TRUE))
# configuraçoes knitr
# configuraçoes knitr
opts_chunk$set(cache = FALSE, 
               fig.path = "figs/", 
               comment = "#>",
               collapse = TRUE)
```

- - -

![](figs/adar.png)

- - -

# Objetivos

Nesta seção vamos:

- conhecer os tipos de dados mais usados no R
- descobrir qual é o tipo de dado de uma variável
- aprender a fazer testes com operadores lógicos
- saber como converter uma variável de um tipo para outro

# Tipos de dados

Existem vários classes de dados no R. As mais utilizadas são:

* `numeric`

* `character` (sequência de caracteres)

* `logical` (TRUE/FALSE)

* `Date` (datas)

* `POSIXct` (datas e horários) 

A classe dos dados de um objeto é verificada com a função `class()`.

```{r chunk1}
x <- 51
class(x)
```
 
## *numeric*

É a classe de objeto mais usada. Essa classe é similar a *float* ou *double* em outras linguagens. Ele lida com inteiros e decimais, positivos e negativos e zero. Um valor numérico armazenado em um objeto é automaticamente assumido ser numérico. Para testar se um objeto é numérico usa-se a função `is.numeric()`.

```{r chunk2}
is.numeric(x)
is.numeric(pi)
```

Outro tipo é o `integer` (inteiro), ou seja não há parte decimal. Para definir um objeto como inteiro é necessário acrescentar ao valor numérico um `L`. Analogamente, uma forma de verificação se o objeto é inteiro é através função `is.integer()`.


```{r chunk3}
i <- 3L
is.integer(i)
is.integer(pi)
```
 
Mesmo com o objeto `i` sendo inteiro, ele também passa na verificação `is.numeric()`.

```{r chunk4}
is.numeric(i)
```

O R converte inteiros para numéricos quando necessário. Vamos usar a função `typeof()` para determinar o tipo de dado e as conversões que o R faz. Por exemplo:

```{r chunk5}
## integer * numeric
typeof(5L)
typeof(4.5)
(prod_i <- 5L * 4.5)
typeof(prod_i)
## integer/integer
typeof(5L)
typeof(2L)
typeof(5L/2L)
# número complexo
typeof(3 + 2i)
```


## *character*

O tipo de dado *character* (*string*) é bastante utilizado e deve ser manipulado com cuidado. No R há duas principais formas de lidar com caracteres: a função `character()` e `factor()`. Embora pareçam similares eles são tratados de forma diferente.

```{r chunk6}
(char <- "Vai chover hoje?")
charf <- factor("Vai chover hoje?")
charf
levels(charf)
ordered(charf)
```

`char` contém as palavras  \"Vai chover hoje?\", enquanto, `charf` tem as mesmas palavras porém sem as aspas e a segunda linha de informação sobre os níveis (*levels*) de `charf`. Nós veremos esse tipos de dado futuramente em vetores.


> **Lembre-se que caracteres em letras minúsculas e maiúsculas são coisas diferentes no R.**

Para encontrar o tamanho de um `character` usamos a função `nchar()`.
        
```{r chunk7}
nchar(char)
nchar("abc")
```       

Esta função não funcionará para um objeto do tipo `factor`.

```{r chunk8, error=TRUE}
nchar(charf)
```       

## *logical*
   
`logical` (lógico) é uma forma de representar dados que podem assumir valores booleanos, isto é, **TRUE** (verdadeiro) ou **FALSE** (falso). 

```{r chunk9}
# variável lógica
vl <- FALSE
``` 

Então em operações aritméticas envolvendo dados lógicos eles serão convertidos numericamente para 1 (TRUE) e 0 (FALSE).

```{r chunk10}
vl * 5
TRUE * 5
TRUE + TRUE
FALSE - TRUE
```

Assim como as outras classes de dados existem funções para verificar a classe de dados lógicos.

```{r chunk11}
class(vl)
is.logical(vl)
```

O R aceita as abreviaturas T e F para representar TRUE e FALSE, respectivamente, mas não é recomendado usá-las, conforme exemplo abaixo.

```{r chunk12, message=FALSE, comment="",prompt=FALSE }
TRUE
T
class(T)
T <- 10
class(T)
```

Valores lógicos resultam da comparação de números ou caracteres.

```{r chunk13}
4 == 3 # 4 é idêntico a 3?
teste2i2 <- 2*2 == 2+2
teste2i2
teste2d2 <- 2*2 != 2+2 # operador: diferente de
teste2d2
4 < 3
4 > 3
4 >= 3 & 4 <= 5
4 <= 3 | 4 <= 5
"abc" == "defg"
"abc" < "defg"
nchar("abc") < nchar("defg")
```

<a name="tab_oper_log"></a>

```{r chunck14, echo = FALSE}
oper <- c("<", "<=", ">", ">=", "==","!=","!x","x | y","x & y","isTRUE(x)", "%in%") 
desc <- c("menor que", " menor ou igual a", "maior que", "maior ou igual", "idêntico","diferente","não é x (negação)","x ou y","x e y","teste se x é verdadeiro", "está contido em") 
operadores_logicos <- data.frame(Operador = oper, 
                                 Descrição = desc, 
                                 stringsAsFactors = FALSE)
kable(operadores_logicos, caption = "Tabela 1. Operadores Lógicos", align = "c")
```



## *Date*

Lidar com datas e horários pode ser difícil em qualquer linguagem e pode complicar mais ainda quando há diversas opções de classes de datas disponíveis, como no R.

As mais úteis são:
  
  * `Date`
  
  * `POSIXct`
  

`Date` armazena apenas a data enquanto `POSIXct` armazena a data e o horário. Ambos dados são representados como o número de dias (Date) ou segundos (POSIXct) decorridos  desde 1 de Janeiro de 1970.
```{r chunk15}
data1 <- as.Date("2012-06-28")
data1
class(data1)
as.numeric(data1)
data2 <- as.POSIXct("2012-06-28 17:42")
data2
class(data2)
as.numeric(data2)
```

A manipulação de dados da classe de datas e horários (`Date-time`) torna-se mais versátil através dos pacotes `lubridate` e `chron`, o que será visto posteriormente no curso.

Funções como `as.numeric()` e `as.Date()` não apenas mudam o formato de um objeto mas muda realmente a classe original do objeto.

```{r chunk16}
class(data1)
class(as.numeric(data1))
```

# Testes sobre tipos de dados

Além função `typeof()`, a família `is.*()` também permite descobrir o tipo de dado, p.ex.: `is.numeric()`, `is.character()` e etc.

```{r}
x; typeof(x)
vl; typeof(vl)
data1; typeof(data1)
x; is.numeric(x)
# checar se um nº é real
is.double(x/5)
is.double(5L)
is.character("12.34")
charf; is.factor(charf)
i; is.integer(i)
is.function(sqrt)
is.finite(i)
is.nan(x)
is.na(x)
```

# Conversão entre tipos de dados

Em algumas circunstâncias precisamos alterar o tipo de uma variável. A maioria das funções `is.*()` possui uma função `as.*()` correspondente de conversão para aquele tipo de dado.

```{r}
# de character para numeric
as.numeric("12.34") 
# ou
as("12.34", "numeric")
# de factor para character
as.character(charf)
# character para factor
as.factor("a")
# de double para integer
typeof(x)
typeof(as.integer(x))
as.integer(x) == 51L
as.integer("12.34")
# arredondamento
as.integer(12.34)
# lógico para inteiro
as.integer(TRUE)
# numérico para lógico
as.logical(0:2)
# character para numérico?
as.numeric("a")
# de character para date
dt_char <- "2016-03-17"
dt <- as.Date(dt_char)
dt
# de character para date-time
data_hora <- as.POSIXct("2016-03-17 15:30:00")
data_hora
```


# Funções e operadores novos utilizados

Tipos de dados

- `class()`
- `factor()`; `levels()`; `ordered()`
- `nchar()`
- `==`; `!=`; `<`; `>`; `>=`; `<=`; `|`;`&`
- `!`

Datas e horas

- `as.Date()`
- `as.POSIXct()`
- `as.numeric()`

Teste dos tipos de dados

- `typeof()`
- `is.numeric()`; `is.character()`; `is.logical()`; `is.integer()`; `is.factor()`; `is.function()`
- `is.finite()`; `is.nan()`; `is.na()`

Conversão de dados

- `as()`; `as.numeric()`; `as.character()`; `as.integer()`; `as.factor()`
- `as.Date()`; `as.POSIXct()`


<br/>

<p style="font-family: verdana; font-size: 14px; font-style: italic; background: whitesmoke; color: black; line-height: 14px;width: 900px;">Próximo: [Estruturas de Dados](https://rawgit.com/jdtatsch/adar-ufsm/master/5_EstruturaDeDados.html)</p>