--- output: knitrBootstrap::bootstrap_document: title: "TESTE YAML" theme: Spacelab highlight: Zenburn theme.chooser: TRUE highlight.chooser: TRUE menu: FALSE --- ```{r setup, include=FALSE, purl=FALSE, eval=TRUE} opts_chunk$set( ## knitr options cache = TRUE, tidy = FALSE, comment = NA, fig.width = 10, fig.height = 8, fig.align = "center", dpi = 80, ## aumentar o dpi para exibir maior. dev = "png", # fig.path = "figures/", ## knitrBootstrap package options (YAML) # bootstrap.title = "TESTE", # bootstrap.theme.chooser = TRUE, # bootstrap.highlight.chooser = TRUE, # bootstrap.theme = "Cosmo", # bootstrap.highlight = "Github", # bootstrap.menu = TRUE, custom.header = NULL, clean_supporting = TRUE, ## knitrBootstrap chunck options bootstrap.thumbnail = TRUE, bootstrap.thumbnail.size = "col-md-12", bootstrap.panel = TRUE, bootstrap.show.code = TRUE, bootstrap.show.output = FALSE, bootstrap.show.message = FALSE, bootstrap.show.warning = FALSE, bootstrap.show.error = FALSE, bootstrap.class = "row" ) ```

CE 083 - Estatística Computacional I

http://www.leg.ufpr.br/ce083


Universidade Federal do Paraná Prof. Fernando de Pol Mayer

Curso de Graduação em Estatística Lab. de Estatística e Geoinformação - LEG

Departamento de Estatística - UFPR


# Sumário Funções e objetos. Classes de objetos. #### Autores e licença Paulo Justiniano Ribeiro Jr., Fernando de Pol Mayer, Walmes Marques Zeviani Licença Creative Commons
Este obra está licenciado com uma Licença Creative Commons Atribuição-NãoComercial-CompartilhaIgual 4.0 Internacional. # Funções e argumentos 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()`) # 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 funções que contenham `palavra`: ```{r eval=FALSE} help.search("palavra") ``` Ajuda através do navegador (também contém manuais, ...): ```{r eval=FALSE} help.start() ``` Busca por `palavra` nos arquivos da lista de discussão do R: ```{r eval=FALSE} RSiteSearch("palavra") ``` # Criando uma função A ideia original do R é transformar usuários em programadores 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 de 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 - 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. - Veja o help da função (?) `"+"` - Crie uma função para fazer a soma de dois números: `x` e `y` # Objetos ## Programação orientada a 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   ⇒   Classes   ⇒   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. As funções genéricas mais importantes são: - `summary()` - `plot()` Veja o resultado de ```{r eval=FALSE} methods(summary) methods(plot) ``` A variável `x` recebe o valor $2$ (tornando-se um objeto dentro do R): ```{r } x <- 2 ``` > 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**. Para ver o conteúdo do objeto: ```{r } x ``` > **Observação**: O símbolo `=` pode ser usado no lugar de `<-` mas não > é recomendado. 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 (*workspace*) 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()) ``` > **Cuidado!** O comando acima apaga todos os objetos na sua área de > trabalho sem perguntar. Depois só é possível recuperar os objetos ao > rodar os script novamente. # 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)$. # Classes de objetos O R possui 5 classes básicas de objetos, também chamados de objetos "atômicos": - `character` - `numeric` - `integer` - `complex` - `logical` > Um vetor só pode conter elementos de uma mesma classe (A única excessão é a lista). ### Vetor 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 class(num) ``` Por que `numeric` e não `integer`? ```{r} x <- c(10L, 5L, 2L, 4L, 8L, 9L) 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. #### Notas sobre 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 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), 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 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 ![Regra da reciclagem](img/reciclagem.png) Agora tente: ```{r eval=FALSE} num + c(2, 4, 1, 3) ``` # Exercícios 1. Crie um objeto com os valores 54, 0, 17, 94, 12.5, 2, 0.9, 15. 1. Some o objeto acima com os valores 5, 6. #### Atributos de objetos Os objetos possuem **atributos**, que servem para descrever o formato do objeto: - `names`, `dimnames` - `length` - `dim` - `class` Classe: ```{r } class(num) ``` Comprimento: ```{r } length(num) ``` Vetores também podem ter outras classes: - Vetor de caracteres: ```{r } caracter <- c("brava", "joaquina", "armação") caracter ``` - Vetor lógico: ```{r } logico <- caracter == "armação" 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: ------ ------------- `<` menor `<=` menor igual `>` maior `>=` maior igual `==` igual `!=` diferente `&` e `|` ou ------ ------------- ### Fator 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) ``` Caso haja uma hierarquia, os níveis dos fatores podem ser ordenados: ```{r } fator <- factor(c("alta","baixa","baixa","media", "alta","media","baixa","media","media"), levels = c("alta","media","baixa")) fator ``` # Exercícios 1. Construa um único objeto com as letras: `A`, `B`, e `C`, repetidas cada uma 15, 12, e 8 vezes, respectivamente. 2. Mostre na tela, em forma de verdadeiro ou falso, onde estão as letras `B` nesse objeto. 3. 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()`). 4. 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. ### 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: > Um vetor só pode conter elementos de uma mesma classe Quando objetos de diferentes classes 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 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) ``` ### Matriz 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) ``` 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 ```{r} m <- 1:10 m class(m) dim(m) dim(m) <- c(2, 5) m class(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 ``` ### Lista Características: - Pode combinar uma coleção de objetos de diferentes classes (é um tipo especial de vetor) - Estrutura “unidimensional”: apenas o número de elementos é contado Utilizando a função `list()`: ```{r } lista <- list(a = 1:10, b = c("T1", "T2", "T3", "T4"), TRUE, 2 + 2) lista class(lista) dim(lista) length(lista) ``` Formando uma lista com objetos criados anteriormente: ```{r } lista <- list(fator = fator, matriz = matriz) lista length(lista) ``` ### Data frame 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(ano = 2000:2004, prod = c(32, 54, 25, 48, 29)) da class(da) dim(da) ``` Data frames podem ser formados com objetos criados anteriormente, desde que tenham o mesmo comprimento! ```{r } length(num) length(fator) da <- data.frame(numerico = c(num, NA, NA, NA), fator = fator) da class(da) dim(da) ## Estrutura dos dados str(da) ``` > A função `str()` é uma das que você precisa decorar! Para converter um data frame para uma matriz ```{r} as.matrix(da) data.matrix(da) ``` Geralmente é o resultado de `data.matrix()` o qeu você está procurando. > Note 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$ ## Nomes Objetos do R podem ter nomes, que facilitam a auto-descrição ```{r} x <- 1:3 names(x) names(x) <- c("Curitiba", "Paraná", "Brasil") x names(x) ``` Listas também podem ter nomes ```{r} x <- list(Curitiba = 1, Paraná = 2, Brasil = 3) x names(x) ``` Associando nomes às *linhas* e *colunas* de uma matriz: ```{r } rownames(matriz) <- c("A","B","C") colnames(matriz) <- c("T1","T2","T3","T4") 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} 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]$$ 1. Atribua nomes para as linhas e colunas dessa matriz. 1. Crie uma lista com dois componentes: (1) um vetor com as letras `A`, `B`, e `C`, repetidas 2, 5, e 4 vezes respectivamente; (2) a matriz do exemplo anterior. 1. Atribua nomes para estes dois componentes da lista. 1. Inclua mais um componente nesta lista, com o nome de `fator`, e que seja um vetor da classe fator, idêntico ao objeto `caracter` criado acima (que possui apenas os nomes `brava`, `joaquina`, `armação`). 1. Você contou 42 caranguejos na Joaquina, 34 no Campeche, 59 na Armação, e 18 na Praia Mole. Crie um data frame para armazenar estas informações (número de caranguejos observados e local).

Última atualização: `r Sys.time()`