02-objetos-classes.Rmd

# Objetos e classes

## Funções e argumentos

```{r external-code-cap2, cache=FALSE, include=FALSE}
knitr::read_chunk("scripts/objetos-classes-exercicios.R")
```

As funções no R são definidas como:

```{r eval=FALSE}
nome(argumento1, argumento2, ...)
```

Exemplo: função `runif()` (para gerar valores aleatórios de uma
distribuição uniforme):

```{r eval=FALSE}
runif(n, min = 0, max = 1)
```
```{r }
runif(10, 1, 100)
```

Argumentos que já possuem um valor especificado (como `max` e `min`)
podem ser omitidos:

```{r eval=FALSE}
runif(10)
```

Se os argumentos forem nomeados, a ordem deles dentro da função não tem
mais importância:

```{r eval=FALSE}
runif(min = 1, max = 100, n = 10)
```

Argumentos nomeados e não nomeados podem ser utilizados, desde que os
não nomeados estejam na posição correta:

```{r eval=FALSE}
runif(10, max = 100, min = 1)
```

### Outros tipos de argumentos

Exemplo: função `sample()`:

```{r eval=FALSE}
sample(x, size, replace = FALSE, prob = NULL)
```

- `x` e `size` devem ser obrigatoriamente especificados.
- `replace` é lógico: `TRUE` (`T`) ou `FALSE` (`F`).
- `prob` é um argumento vazio ou ausente (“opcional”).

Exemplo: função `plot()`:

```{r eval=FALSE}
plot(x, y, ...)
```

- "`...`" permite especificar argumentos de outras funções (por exemplo
  `par()`).

Para ver todos os argumentos disponíveis de uma função, podemos usar a
função `args()`.

```{r}
args(sample)
```

## Mecanismos de ajuda

Argumentos e detalhes do funcionamento das funções:

```{r eval=FALSE}
?runif
```

ou

```{r eval=FALSE}
help(runif)
```

A documentação contém os campos:

- **Description:** breve descrição.
- **Usage:** função e todos seus argumentos.
- **Arguments:** lista descrevendo cada argumento.
- **Details:** descrição detalhada.
- **Value:** o que a função retorna.
- **References:** bibliografia relacionada.
- **See Also:** funções relacionadas.
- **Examples:** exemplos práticos.

Procura por nomes de funções que contenham algum termo:

```{r eval=FALSE}
apropos("mod")
apropos("model")
```

Procura por funções que contenham `palavra` em qualquer parte de sua
documentação:

```{r eval=FALSE}
help.search("palavra")
```

Ajuda através do navegador (também contém manuais, ...):

```{r eval=FALSE}
help.start()
```

Sites para busca na documentação dos diversos pacotes:

- RDocumentation https://www.rdocumentation.org/.
- R Package Documentation https://rdrr.io/.
- R Contributed Documentation (várias línguas).
  https://cran.r-project.org/other-docs.html.

Os pacotes do R contêm funções específicas para determinadas tarefas, e
estendem a instalação básica do R. Atualmente existem mais de 10000
pacotes disponíveis no
[CRAN](http://cran-r.c3sl.ufpr.br/web/packages/index.html), além de
diversos outros hospedados em sites como [Github](https://github.com),
por exemplo.

Ao instalar o R, os seguintes pacotes já vêm instalados (fazem parte do
chamado "R core"):

```{r, echo=FALSE}
rownames(installed.packages(lib.loc = paste0(R.home(), "/library")))
```

No entanto, nem todos são carregados na inicialização do R. Por padrão,
apenas os seguintes pacotes são carregados automaticamente:

```{r, echo=FALSE}
gsub("package:", "", grep("^package", search(), value = TRUE)[-c(1,2)])
```

Para listar os pacotes carregados, use a função

```{r, eval=FALSE}
search()
```

Note que o primeiro elemento, `.GlobalEnv`, será sempre carregado pois
ele é o *ambiente* que irá armazenar (e deixar disponível) os objetos
criados pelo usuário. Para carregar um pacote instalado, usamos a função
`library()`, por exemplo

```{r, eval=FALSE}
library(lattice)
search()
```

Isso tornará todas as funções do pacote `lattice` disponíveis para uso.

Para instalar um pacote usamos a função `install.packages()`. Sabendo o
nome do pacote, por exemplo, `mvtnorm`, fazemos

```{r, eval=FALSE}
install.packages("mvtnorm")
```

Se o diretório padrão de instalação de um pacote for de acesso restrito
(root por exemplo), o R irá perguntar se você gostaria de instalar o
pacote em uma biblioteca pessoal, e sugerirá um diretório que possui as
permissões necessárias. Você pode se antecipar e já definir e criar um
diretório na sua pasta pessoal, e instalar os pacotes sempre nesse
local. Por exemplo, defina `~/R/library` como sua biblioteca pessoal.
Para instalar os pacotes sempre nesse diretório faça:

```{r, eval=FALSE}
install.packages("mvtnorm", lib = "~/R/library")
```

Para verificar as bibliotecas disponíveis e se existem pacotes para serem
atualizados, use

```{r, eval=FALSE}
packageStatus()
```

Para atualizar automaticamente todos os pacotes faça

```{r, eval = FALSE}
update.packages(ask = FALSE)
```

## Criando uma função

A ideia original do R é transformar usuários em programadores

> *"... to turn ideas into software, quickly and faithfully."*
>
> -- John M. Chambers.

Criar funções para realizar trabalhos específicos é um dos grandes
poderes do R.

Por exemplo, podemos criar a famosa função

```{r }
ola.mundo <- function(){
    writeLines("Olá mundo")
}
```

E chama-la através de

```{r }
ola.mundo()
```

A função acima não permite alterar o resultado da saída. Podemos fazer
isso incluindo um **argumento**

```{r }
ola.mundo <- function(texto){
    writeLines(texto)
}
```

E fazer por exemplo

```{r }
ola.mundo("Funções são legais")
```

(Veremos detalhes de funções mais adiante)

## Exercícios {-}

1. Usando a função `runif()` gere $30$ números aleatórios entre:
    - 0 e 1
    - -5 e 5
    - 10 e 500

  alternando a posição dos argumentos da função.

2. Veja o help da função (?) `"+"`
3. Crie uma função para fazer a soma de dois números: `x` e `y`
4. Crie uma função para simular a jogada de um dado.
5. Crie uma função para simular a jogada de dois dados.

```{r ex1, eval=FALSE, include=FALSE}
```

## Objetos

O que é um objeto?

- Um **símbolo** ou uma **variável** capaz de armazenar qualquer valor
  ou estrutura de dados.

Por quê objetos?

- Uma maneira simples de acessar os dados armazenados na memória (o R
  não permite acesso direto à memória).

Programação:

- Objetos $\Rightarrow$ Classes $\Rightarrow$ Métodos.

> *“Tudo no R é um objeto.”*

> *“Todo objeto no R tem uma classe.”*

- **Classe:** é a definição de um objeto. Descreve a forma do objeto e
  como ele será manipulado pelas diferentes funções.
- **Método:** são **funções genéricas** que executam suas tarefas de
  acordo com cada classe. Duas das funções genéricas mais importantes
  são:
    - `summary().`
    - `plot().`

Veja o resultado de

```{r eval=FALSE}
methods(summary)
methods(plot)
```

(Veremos mais detalhes adiante).

A variável `x` recebe o valor $2$ (tornando-se um objeto dentro do R):

```{r }
x <- 2
```

<div class="alert alert-warning">
O símbolo `<-` é chamado de **operador de atribuição**. Ele serve para
atribuir valores a objetos, e é formado pelos símbolos `<` e `-`,
obrigatoriamente **sem espaços**.
</div>

Para ver o conteúdo do objeto:

```{r }
x
```

<div class="alert alert-warning">
**Observação**: O símbolo `=` pode ser usado no lugar de `<-` mas não
é recomendado.
</div>

Quando você faz

```{r }
x <- 2
```

está fazendo uma **declaração**, ou seja, declarando que a variável `x`
irá agora se tornar um objeto que armazena o número `2`. As declarações
podem ser feitas uma em cada linha

```{r }
x <- 2
y <- 4
```

ou separadas por `;`

```{r }
x <- 2; y <- 4
```

Operações matemáticas em objetos:

```{r }
x + x
```

Objetos podem armazenar diferentes estruturas de dados:

```{r }
y <- runif(10)
y
```

Note que cada objeto só pode armazenar uma estrutura (um número ou uma
sequência de valores) de cada vez! (Aqui, o valor $4$ que estava
armazenado em `y` foi sobrescrito pelos valores acima).

### Nomes de objetos

- Podem ser formados por letras, números, "`_`", e "`.`".
- Não podem começar com número e/ou ponto.
- Não podem conter espaços.
- Evite usar acentos.
- Evite usar nomes de funções como:

`c q t C D F I T diff df data var pt`

- O R é *case-sensitive*, portanto:

`dados` $\neq$ `Dados` $\neq$ `DADOS`.

### Gerenciando a área de trabalho

Liste os objetos criados com a função `ls()`:

```{r eval=FALSE}
ls()
```

Para remover apenas um objeto:

```{r eval=FALSE}
rm(x)
```

Para remover outros objetos:

```{r eval=FALSE}
rm(x, y)
```

Para remover todos os objetos:

```{r eval=FALSE}
rm(list = ls())
```

<div class="alert alert-danger">
**Cuidado!** O comando acima apaga todos os objetos na sua área de
trabalho sem perguntar. Depois só é possível recuperar os objetos ao
rodar o script novamente.
</div>

## Exercícios {-}

1. Armazene o resultado da equação $32 + 16^2 - 25^3$ no objeto `x`.
2. Divida `x` por $345$ e armazene em `y`.
3. Crie um objeto (com o nome que você quiser) para armazenar $30$
   valores aleatórios de uma distribuição uniforme entre $10$ e $50$.
4. Remova o objeto `y`.
5. Remova os demais objetos de uma única vez.
6. Procure a função utilizada para gerar numeros aleatórios de uma
   distribuição de Poisson, e gere $100$ valores para a VA $X \sim
   \text{Poisson}(5)$.

```{r ex2, eval=FALSE, include=FALSE}
```

## Tipos e classes de objetos

Para saber como trabalhar com dados no R, é fundamental entender as
possíveis estruturas (ou tipos) de dados possíveis. O formato mais
básico de dados são os vetores, e a partir deles, outras estruturas mais
complexas podem ser construídas. O R possui dois tipos básicos de
vetores:

- **Vetores atômicos**: existem seis tipos básicos:
  - `double`.
  - `integer`.
  - `character`.
  - `logical`.
  - `complex`.
  - `raw`.

  Os tipos `integer` e `double` são chamados conjuntamente de `numeric`.

- **Listas**: também chamadas de *vetores recursivos* pois listas podem
  conter outras listas.

A principal diferença entre vetores atômicos e listas é que o primeiro é
**homogêneo** (cada vetor só pode conter um tipo), enquanto que o
segundo pode ser **heterogêneo** (cada vetor pode conter mais de um
tipo).

<div class="alert alert-warning">
Um vetor atômico só pode conter elementos de um mesmo tipo.
</div>

Um vetor, como o próprio nome diz, é uma estrutura unidimensional, mas
na maioria das vezes iremos trabalhar com estruturas de dados
bidimensionais (linhas e colunas). Portanto diferentes estruturas (com
diferentes dimensões) podem ser criadas a partir dos vetores atômicos.
Quando isso acontece, temos o que é chamado de **classe** de um objeto.
Embora os vetores atômicos só possuam seis tipos básicos, existe um
número muito grande de classes, e novas são inventadas todos os dias. E
mesmo que um objeto seja de qualquer classe, ele sempre será de um dos
seis tipos básicos (ou uma lista).

Para verificar o tipo de um objeto, usamos a função `typeof()`, enquanto
que a classe é verificada com a função `class()`. Vejamos alguns
exemplos:

```{r}
## double
x <- c(2, 4, 6)
typeof(x)
class(x)
## integer
x <- c(2L, 4L, 6L)
typeof(x)
class(x)
## character
x <- c("a", "b", "c")
typeof(x)
class(x)
## logical
x <- c(TRUE, FALSE, TRUE)
typeof(x)
class(x)
## complex
x <- c(2 + 1i, 4 + 1i, 6 + 1i)
typeof(x)
class(x)
## raw
x <- raw(3)
typeof(x)
class(x)
```

### Vetores numéricos

Características:

- Coleção ordenada de valores.
- Estrutura unidimensional.

Usando a função `c()` para criar vetores:

```{r }
num <- c(10, 5, 2, 4, 8, 9)
num
typeof(num)
class(num)
```

Por que `numeric` e não `integer`?

```{r}
x <- c(10L, 5L, 2L, 4L, 8L, 9L)
x
typeof(x)
class(x)
```

Para forçar a representação de um número para inteiro é necessário usar
o sufixo `L`.

Note que a diferença entre `numeric` e `integer` também possui impacto
computacional, pois o armazenamento de números inteiros ocupa menos
espaço na memória. Dessa forma, esperamos que o vetor `x` acima ocupe
menos espaço na memória do que o vetor `num`, embora sejam aparentemente
idênticos. Veja:

```{r}
object.size(num)
object.size(x)
```

A diferença pode parecer pequena, mas pode ter um grande impacto
computacional quando os vetores são formados por milhares ou milhões de
números.

#### Representação numérica dentro do R

Os números que aparecem na tela do console do R são apenas
representações simplificadas do número real armazenado na memória. 
Por exemplo,

```{r, echo = -1}
set.seed(123)
x <- runif(10)
x
```

O objeto `x` contém números como `r x[1]`, `r x[2]`, etc, que possuem 7
casas decimais, que é o padrão do R. O número de casas decimais é
controlado pelo argumento `digits` da função `options()`. Para visualizar
essa opção, use

```{r}
getOption("digits")
```

Note que esse valor de 7 é o número de **dígitos significativos**, e
pode variar conforme a sequência de números. Por exemplo,

```{r, echo = -1}
set.seed(12)
y <- runif(10)
y
```

possui valores com 9 casas decimais. Isto é apenas a representação do
número que aparece na tela. Internamente, cada número é armazenado com
uma precisão de 64 bits. Como consequência, cada número possui uma
acurácia de até 16 dígitos significativos. Isso pode introduzir algum
tipo de erro, por exemplo:

```{r}
sqrt(2)^2 - 2
print(sqrt(2)^2, digits = 22)
```

não é exatamente zero, pois a raíz quadrada de 2 não pode ser armazenada
com toda precisão com "apenas" 16 dígitos significativos. Esse tipo de
erro é chamado de **erro de ponto flutuante**, e as operações nessas
condições são chamadas de **aritmética de ponto flutuante**. Para mais
informações sobre esse assunto veja [What Every Computer Scientist
Should Know About Floating-Point
Arithmetic](http://www.validlab.com/goldberg/paper.pdf) e [Why doesn’t R
think these numbers are
equal?](http://cran-r.c3sl.ufpr.br/doc/FAQ/R-FAQ.html#Why-doesn_0027t-R-think-these-numbers-are-equal_003f).

No R os números podem ser representados com até 22 casas decimais. Você
pode ver o número com toda sua precisão usando a função `print()` e
especificando o número de casas decimais com o argumento `digits` (de 1
a 22).

```{r}
print(x, digits = 1)
print(x, digits = 7) # padrão
print(x, digits = 22)
```

Também é possível alterar a representação na tela para o formato
científico, usando a função `format()`

```{r, echo = -1}
xf <- format(x, scientific = TRUE)
format(x, scientific = TRUE)
```

Nessa representação, o valor `r xf[1]` = $2.875775 \times 10^{-01}$ =
$`r x[1]`$.

#### Sequências de números

Usando a função `seq()`

```{r }
seq(1, 10)
```

Ou `1:10` gera o mesmo resultado. Para a sequência variar em $2$

```{r }
seq(from = 1, to = 10, by = 2)
```

Para obter $15$ valores entre $1$ e $10$

```{r }
seq(from = 1, to = 10, length.out = 15)
```

Usando a função `rep()`

```{r }
rep(1, 10)
```

Para gerar um sequência várias vezes

```{r }
rep(c(1, 2, 3), times = 5)
```

Para repetir um número da sequência várias vezes

```{r }
rep(c(1, 2, 3), each = 5)
```

#### Operações matemáticas em vetores numéricos

Operações podem ser feitas entre um vetor e um número:

```{r }
num * 2
```

E também entre vetores de mesmo comprimento ou com comprimentos
múltiplos:

```{r }
num * num
num + c(2, 4, 1)
```

#### A Regra da Reciclagem

```{r, echo=FALSE, out.width='80%'}
knitr::include_graphics("img/reciclagem.png")
```

Agora tente:

```{r eval=FALSE}
num + c(2, 4, 1, 3)
```

### Outros tipos de vetores

Vetores também podem ter outros tipos:

- Vetor de caracteres:
```{r }
caracter <- c("brava", "joaquina", "armação")
caracter
typeof(caracter)
class(caracter)
```
- Vetor lógico:
```{r }
logico <- caracter == "armação"
logico
typeof(logico)
class(logico)
```
ou
```{r }
logico <- num > 4
logico
```

No exemplo anterior, a condição `num > 4` é uma **expressão
condicional**, e o símbolo `>` um **operador lógico**.  Os operadores
lógicos utilizados no R são:

| Operador  | Sintaxe          | Teste                                |
| :-------: | :------------    | :-----                               |
| `<`       | `a < b`          | `a` é menor que `b`?                 |
| `<=`      | `a <= b`         | `a` é menor ou igual a `b`?          |
| `>`       | `a > b`          | `a` é maior que `b`                  |
| `>=`      | `a >= b`         | `a` é maior ou igual a `b`?          |
| `==`      | `a == b`         | `a` é igual a `b`?                   |
| `!=`      | `a != b`         | `a` é diferente de `b`?              |
| `%in%`    | `a %in% c(a, b)` | `a` está contido no vetor `c(a, b)`? |


### Misturando classes de objetos

Algumas vezes isso acontece por acidente, mas também pode acontecer de
propósito.

O que acontece aqui?

```{r}
w <- c(5L, "a")
x <- c(1.7, "a")
y <- c(TRUE, 2)
z <- c("a", T)
```

Lembre-se da regra:

<div class="alert alert-warning">
Um vetor só pode conter elementos do mesmo tipo!
</div>

Quando objetos de diferentes tipos são misturados, ocorre a
**coerção**, para que cada elemento possua a mesma classe.

Nos exemplos acima, nós vemos o efeito da **coerção implícita**, quando
o R tenta representar todos os objetos de uma única forma.

Nós podemos forçar um objeto a mudar de classe, através da **coerção
explícita**, realizada pelas funções `as.*`:

```{r}
x <- 0:6
typeof(x)
class(x)
as.numeric(x)
as.logical(x)
as.character(x)
as.factor(x)
```

De `?logical`:

     Logical vectors are coerced to integer vectors in contexts where a
     numerical value is required, with ‘TRUE’ being mapped to ‘1L’,
     ‘FALSE’ to ‘0L’ and ‘NA’ to ‘NA_integer_’.

```{r}
(x <- c(FALSE, TRUE))
class(x)
as.numeric(x)
```

Algumas vezes não é possível fazer a coerção, então:

```{r}
x <- c("a", "b", "c")
as.numeric(x)
as.logical(x)
```

### Valores perdidos e especiais

Valores perdidos devem ser definidos como `NA` (*not available*):

```{r }
perd <- c(3, 5, NA, 2)
perd
class(perd)
```

Podemos testar a presença de `NA`s com a função `is.na()`:

```{r }
is.na(perd)
```

Ou:

```{r }
any(is.na(perd))
```

Outros valores especiais são:

- `NaN` (*not a number*) - exemplo: `0/0`
- `-Inf` e `Inf` - exemplo: `1/0`

A função `is.na()` também testa a presença de `NaN`s:

```{r }
perd <- c(-1,0,1)/0
perd
is.na(perd)
```

A função `is.infinite()` testa se há valores infinitos

```{r }
is.infinite(perd)
```

## Exercícios {-}

1.  Crie um objeto com os valores 54, 0, 17, 94, 12.5, 2, 0.9, 15.
    a. Some o objeto acima com os valores 5, 6, e depois com os valores 5,
    6, 7.
2. Construa um único objeto com as letras: `A`, `B`, e `C`, repetidas
   cada uma 15, 12, e 8 vezes, respectivamente.
    a. Mostre na tela, em forma de verdadeiro ou falso, onde estão as letras
    `B` nesse objeto.
    b. Veja a página de ajuda da função `sum()` e descubra como fazer para
    contar o número de letras `B` neste vetor (usando `sum()`).
3. Crie um objeto com 100 valores aleatórios de uma distribuição uniforme
   $U(0,1)$. Conte quantas vezes aparecem valores maiores ou iguais a 0,5.
4. Calcule as 50 primeiras potências de 2, ou seja, $2, 2^2, 2^3,
   \ldots, 2^{50}$.
    a. Calcule o quadrado dos números inteiros de 1 a 50, ou seja, $1^2,
    2^2, 3^2, \ldots, 50^2$.
    b. Quais pares são iguais, ou seja, quais números inteiros dos dois
    exercícios anteriores satisfazem a condição $2^n = n^2$?
    c. Quantos pares existem?
5. Calcule o seno, coseno e a tangente para os números variando de $0$ a
   $2\pi$, com distância de $0.1$ entre eles. (Use as funções `sin()`,
   `cos()`, `tan()`).
    a. Calcule a tangente usando a relação $\tan(x) = \sin(x)/\cos(x)$.
    b. Calcule as diferenças das tangentes calculadas pela função do R e
   pela razão acima.
    c. Quais valores são exatamente iguais?
    d. Qual a diferença máxima (em módulo) entre eles? Qual é a causa
   dessa diferença?

```{r ex3, eval=FALSE, include=FALSE}
```

## Outras classes

Como mencionado na seção anterior, o R possui 6 tipos básicos de
estrutura de dados, mas diversas classes podem ser construídas a partir
destes tipos básicos. Abaixo, veremos algumas das mais importantes.

### Fator

Os fatores são parecidos com caracteres no R, mas são armazenados e
tratados de maneira diferente.

Características:

- Coleção de categorias ou **níveis** (*levels*).
- Estrutura unidimensional.

Utilizando as funções `factor()` e `c()`:

```{r }
fator <- factor(c("alta","baixa","baixa","media",
                  "alta","media","baixa","media","media"))
fator
class(fator)
typeof(fator)
```

Note que o objeto é da classe `factor`, mas seu tipo básico é `integer`!
Isso significa que cada categoria única é identificada internamente por
um número, e isso faz com que os fatores possuam uma ordenação, de
acordo com as categorias únicas. Por isso existe a identificação dos
`Levels` (níveis) de um fator.

Veja o que acontece quando "remover a classe" desse objeto

```{r}
unclass(fator)
```

Fatores podem ser convertidos para caracteres, e **também** para números
inteiros

```{r}
as.character(fator)
as.integer(fator)
```

Caso haja uma hierarquia, os níveis dos fatores podem ser ordenados
explicitamente através do argumento `levels`:

```{r }
fator <- factor(c("alta","baixa","baixa","media",
                  "alta","media","baixa","media","media"),
                levels = c("alta","media","baixa"))
fator
typeof(fator)
class(fator)
```

Além disso, os níveis dos fatores podem também ser explicitamente
ordenados

```{r }
fator <- factor(c("alta","baixa","baixa","media",
                  "alta","media","baixa","media","media"),
                levels = c("baixa", "media", "alta"),
                ordered = TRUE)
fator
typeof(fator)
class(fator)
```

Veja que um objeto pode ter mais de uma classe. Isso geralmente só
será útil em casos especificos.

As seguintes funções são úteis para verificar os níveis e o número de
níveis de um fator:

```{r}
levels(fator)
nlevels(fator)
```

### Matriz

Matrizes são vetores que podem ser dispostos em duas dimensões.

Características:

- Podem conter apenas um tipo de informação (números, caracteres)
- Estrutura bidimensional

Utilizando a função `matrix()`:

```{r }
matriz <- matrix(1:12, nrow = 3, ncol = 4)
matriz
class(matriz)
typeof(matriz)
```

Alterando a ordem de preenchimento da matriz (por linhas):

```{r }
matriz <- matrix(1:12, nrow = 3, ncol = 4, byrow = TRUE)
matriz
```

Para verificar a dimensão da matriz:

```{r }
dim(matriz)
```

Adicionando colunas com `cbind()`

```{r }
cbind(matriz, rep(99, 3))
```

Adicionando linhas com `rbind()`

```{r }
rbind(matriz, rep(99, 4))
```

Matrizes também podem ser criadas a partir de vetores adicionando um
**atributo** de dimensão, por exemplo,

```{r}
m <- 1:10
m
class(m)
dim(m)
dim(m) <- c(2, 5)
m
class(m)
typeof(m)
```

#### Operações matemáticas em matrizes

Matriz multiplicada por um escalar

```{r }
matriz * 2
```

Multiplicação de matrizes (observe as dimensões!)

```{r }
matriz2 <- matrix(1, nrow = 4, ncol = 3)
matriz %*% matriz2
```

### Array

Um array é a forma mais geral de uma matriz, pois pode ter $n$
dimensões.

Características:

- Estrutura $n$-dimensional.
- Assim como as matrizes, podem conter apenas um tipo de informação
  (números, caracteres).

Para criar um array, usamos a função `array()`, passando como primeiro
argumento um vetor atômico, e especificamos a dimensão com o argumento
`dim`. Por exemplo, para criar um objeto com 3 dimensões $2 \times 2
\times 3$, fazemos

```{r}
ar <- array(1:12, dim = c(2, 2, 3))
ar
```

Similarmente, um array de 2 dimensões $3 \times 2 \times 2$ é obtido com

```{r}
ar <- array(1:12, dim = c(3, 2, 2))
ar
```

### Lista

Como já vimos, uma lista não é uma "classe" propriamente dita, mas sim
um tipo de estrutura de dados básico, ao lado dos vetores atômicos. E,
assim como os vetores atômicos, listas são estruturas unidimensionais. A
grande diferença é que listas agrupam objetos de diferentes tipos,
inclusive outras listas.

Características:

- Pode combinar uma coleção de objetos de diferentes tipos ou classes (é
  um tipo básico de vetor, assim como os vetores atômicos).
- Estrutura “unidimensional”: apenas o número de elementos na lista é
  contado.

Por exemplo, podemos criar uma lista com uma sequência de números, um
caracter e outra lista.

```{r }
lista <- list(1:30, "R", list(TRUE, FALSE))
lista
class(lista)
typeof(lista)
```

Para melhor visualizar a estrutura dessa lista (ou de qualquer outro
objeto) podemos usar a função `str()`

```{r}
str(lista)
```

Note que de fato é uma estrutura unidimensional

```{r}
dim(lista)
length(lista)
```

Listas podem armazenar objetos de diferentes classes e dimensões, por
exemplo, usando objetos criados anteriormente

```{r }
lista <- list(fator, matriz)
lista
length(lista)
```

### Data frame

Data frame é a versão bidimensional de uma lista. Data frames **são**
listas, mas onde cada componente deve ter obrigatoriamente o mesmo
comprimento. Cada vetor da lista vira uma coluna em um data frame,
permitindo então que as "colunas" sejam de diferentes tipos.

Os data frames são as estruturas mais comuns para se trabalhar com dados
no R.

Características:

- Uma lista de vetores e/ou fatores, de **mesmo comprimento**.
- Pode conter diferentes tipos de dados (numérico, fator, ...).
- Estrutura bidimensional.

Utilizando a função `data.frame()`:

```{r }
da <- data.frame(nome = c("João", "José", "Maria"),
                 sexo = c("M", "M", "F"),
                 idade = c(32, 34, 30))
da
class(da)
typeof(da)
dim(da)
```

Veja os detalhes com `str()`

```{r}
str(da)
```

Em versões anteriores a função `data.frame()` convertia caracteres para fator
automaticamente mas o padrão mudou. Use o argumento `stringsAsFactors` para controlar este comportamento.

```{r }
da <- data.frame(nome = c("João", "José", "Maria"),
                 sexo = c("M", "M", "F"),
                 idade = c(32, 34, 30))
da 
str(da)

da <- data.frame(nome = c("João", "José", "Maria"),
                 sexo = c("M", "M", "F"),
                 idade = c(32, 34, 30),
                 stringsAsFactors = FALSE)
str(da)
	
da <- data.frame(nome = c("João", "José", "Maria"),
                 sexo = c("M", "M", "F"),
                 idade = c(32, 34, 30),
                 stringsAsFactors = TRUE)
str(da)
```

Data frames podem ser formados com objetos criados anteriormente, desde
que tenham o mesmo comprimento:

```{r }
length(num)
length(fator)
db <- data.frame(numerico = c(num, NA, NA, NA),
                 fator = fator)
db
str(db)
```

Algumas vezes pode ser necessário converter um data frame para uma
matriz. Existem duas opções:

```{r}
as.matrix(db)
data.matrix(db)
```

Geralmente é o resultado de `data.matrix()` o que você está procurando.

<div class="alert alert-warning">
Lembre que os níveis de um fator são armazenados internamente como
números: $1^\circ$ nível = 1, $2^\circ$ nível = 2, $\ldots$.
```{r}
fator
str(fator)
as.numeric(fator)
```
</div>

## Atributos de objetos

Um atributo é um pedaço de informação que pode ser "anexado" à qualquer
objeto, e não irá interferir nos valores daquele objeto. Os atributos
podem ser vistos como "metadados", alguma descrição associada à um
objeto. Os principais atributos são:

- `names`
- `dimnames`
- `dim`
- `class`

Alguns atributos também podem ser visualizados de uma só vez através da
função `attributes()`.

Por exemplo, considere o seguinte vetor

```{r}
x <- 1:6
attributes(x)
```

Mostra que o objeto `x` não possui nenhum atributo. Mas podemos definir
nomes, por exemplo, para cada componente desse vetor

```{r}
names(x)
names(x) <- c("um", "dois", "tres", "quatro", "cinco", "seis")
names(x)
attributes(x)
```

Nesse caso específico, o R irá mostrar os nomes acima dos componentes,
mas isso não altera como as operaçõs serão realizadas.

```{r}
x
x + 2
```

Os nomes então podem ser definidos através da função *auxiliar*
`names()`, sendo assim, também podemos remover esse atributo declarando
ele como nulo.

```{r}
names(x) <- NULL
attributes(x)
x
```

Outros atributos também podem ser definidos de maneira similar. 
Veja os exemplos abaixo:

```{r}
length(x)
## Altera o comprimento (preenche com NA)
length(x) <- 10
x
## Altera a dimensão
length(x) <- 6
dim(x)
dim(x) <- c(3, 2)
x
attributes(x)
## Remove dimensão
dim(x) <- NULL
x
```

Assim como vimos em data frames, listas também podem ter nomes

```{r}
x <- list(Curitiba = 1, Paraná = 2, Brasil = 3)
x
names(x)
```

Podemos também associar nomes às *linhas* e *colunas* de uma matriz:

```{r }
matriz
attributes(matriz)
rownames(matriz) <- c("A","B","C")
colnames(matriz) <- c("T1","T2","T3","T4")
matriz
attributes(matriz)
```

Para data frames existe uma função especial para os nomes de linhas,
`row.names()`. Data frames também não possuem nomes de colunas, apenas
nomes, já que é um caso particular de lista. Então para
verificar/alterar nomes de colunas de um data frame também use
`names()`.

```{r}
da
attributes(da)
names(da)
row.names(da)
```

Um resumo das funções para alterar/acessar nomes de linhas e colunas em
matrizes e data frames.


 Classe      | Nomes de colunas | Nomes de linhas
 ----------- |------------------|---------------
`data.frame` | `names()`        | `row.names()`
`matrix`     | `colnames()`     | `rownames()`


## Exercícios {-}

1.  Crie um objeto para armazenar a seguinte matriz
    $$\left[ \begin{array}{ccc}
            2 & 8 & 4 \\
            0 & 4 & 1 \\
            9 & 7 & 5
			\end{array} \right]$$
2. Atribua nomes para as linhas e colunas dessa matriz.
3. Crie uma lista (**não nomeada**) com dois componentes: (1) um vetor
   com as letras `A`, `B`, e `C`, repetidas 2, 5, e 4 vezes
   respectivamente; e (2) a matriz do exemplo anterior.
4. Atribua nomes para estes dois componentes da lista.
5. Inclua mais um componente nesta lista, com o nome de `fator`, e que
   seja um vetor da classe `factor`, idêntico ao objeto `caracter` criado
   acima (que possui apenas os nomes `brava`, `joaquina`, `armação`).
6. Crie um data frame para armazenar duas variáveis: local (`A`, `B`,
   `C`, `D`), e contagem (42, 34, 59 e 18).
7. Crie um data frame com as seguintes colunas:
  - Nome
  - Sobrenome
  - Se possui animal de estimação
  - Caso possua, dizer o número de animais (caso contrário, colocar 0)

  Para criar o data frame, a primeira linha deve ser preenchida com as
  suas próprias respostas (use a função `data.frame()`). Depois, pergunte
  essas mesmas questões para dois colegas ao seu lado, e adicione as
  respostas deles à esse data frame (use `rbind()`). Acresente mais uma
  coluna com o nome do time de futebol de cada um.


```{r ex3, eval=FALSE, include=FALSE}
```

## Referências {-}

Para mais detalhes e exemplos dos assuntos abordados aqui, veja
@Grolemund2014. Uma abordagem mais avançada e detalhada sobre
programação orientada a objetos no R pode ser consultada em
@Wickham2015.

<!-- Isso faz com que as referências se mantenham noo final do capítulo -->
<div id="refs">
</div>