• Desenvolvido por Ross Ihaka e Robert Gentleman.
• Surigiu em 1993.
• University of Auckland, New Zealand.

• Implementação da Linguagem S de John Chambers.
• Desenvolvido pelo the R Development Core Team.
• Cross-plataforma (Linux, MAC, Windows).
• FOSS: free and open source software.
• > 12 mil pacotes oficiais no CRAN.
• Centenas em desenvolvimento no GitHub.

"R"efletions: um pouco da história e experiências com o R - Paulo Justiniano Ribeiro Jr

# Adiciona repositório para fontes do R (Ubuntu).
sudo add-apt-repository echo \
     "deb http://cloud.r-project.org/bin/linux/ubuntu $(lsb_release -cs)-cran35/"

# Adiciona chaves de segurança.
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E084DAB9

# Atualiza a lista de repositórios
sudo apt-get update

# Instala o R.
sudo apt-get install r-base r-base-core

• CLI - Command Line Interface
• REPL - Read, Eval, Print and Loop

# NOTE: Texto após o sinal de hash (#) não é interpretado, serve de
# recurso para fazer comentários no código.

2 + 6 + 5 + 9 + 3 + 2 # Comentário pode ser após alguma instrução.

# Uma intrução pode ser dividida em duas linhas.
2 + 6 + 5 +
    9 + 3 + 2

# E em uma linha podem existir mais de uma instrução.
2 + 6; 14 + 12

x <- 3          # Atribuição
x               # Avalia a expressão e exibe o resultado.

y <- 4
y + 5

z <- x + 17 * y # Usa variáveis criadas.
z

rm(z)           # Remove z: apaga o objeto da memória.
z               # Error!

O conteúdo das próximos páginas foi traduzido de https://kateto.net/networks-r-igraph.

2 == 2  # Igualdade
2 != 2  # Desigualdade
x <= y  # Outros operadores: "<", ">", and ">=".

(2 < 5) & (7 >= 3) # Operador AND.
(2 < 5) | (7 >= 3) # Operador OR.
!(2 < 5)           # Operador NOT.

• NA: para valores ausentes.
• NULL: para objetos vazios.
• Inf e -Inf: para infinitos.
• NaN: para resultados não razoavelmente definidos.

5 + NA         # O resultado é NA.
is.na(5 + NA)  # Verifica se é NA.

10 + NULL      # Retorna objeto vazio.
is.null(NULL)  # Verifica se é nulo.

5/0            # Infinito.
is.finite(5/0) # Verifica se é finito.

0/0            # Valor indeterminado.
is.nan(0/0)    # Verifica se é not a number.

• O vetor tem tipo de valor homogêneo, i.e. todos os elementos do mesmo tipo de valor.

v1 <- c(1, 5, 11, 33)      # Vetor numérico.
v2 <- c("hello", "world")  # Vetor de caracteres.
v3 <- c(TRUE, TRUE, FALSE) # Vetor lógico.

# Coerção para o tipo mais geral.
v4 <- c(v1, v2, v3, "boo")

# Sequências e repetições.
v <- 1:7
v <- rep(0, 77)
v <- rep(1:3, times = 2)
v <- rep(1:10, each = 2)
v <- seq(10, 20, 2)

• IMPORTANT: regra da reciclagem.

v1 <- 1:5
v2 <- rep(1, 5)
length(v1)
length(v2)

# Operações entre vetores.
v1 + v2      # Adição elemento a elemento.
v1 + 1       # Adição.
v1 * 2       # Multiplicação.
v1 + c(1, 7) # Aviso! Vetores de tamanhos não múltiplos.

## Warning in v1 + c(1, 7): longer object length is not a multiple of shorter
## object length

# Operações matemáticas.
sum(v1)      # Soma.
mean(v1)     # Média.
sd(v1)       # Desvio-padrão.
median(v1)   # Mediana.

# Operações lógicas.
v1 > 2       # Compara cada um.
v1 == v2     # Comparação elemento a elemento.

(v1 > 2) | (v2 > 0)   # | é vetorial --> retorna vetor.
(v1 > 2) & (v2 > 0)   # & é vetorial --> retorna vetor.
(v1 > 2) || (v2 > 0)  # || é escalar --> retorna um valor.
(v1 > 2) && (v2 > 0)  # && é escalar --> retorna um valor.

• Indexação no R começa em 1.
• T e F são aliases para TRUE e FALSE MAS não são palavras reservadas!

# Seleção de elementos.
v1[3]
v1[-3]
v1[2:4]
v1[c(1, 3)]
v1[c(T, T, F, F, F)]
v1[v1 > 3]

• factor() deve ser usado para declarar variáveis categóricas.
• São armazenadas como inteiro com uma tabela de associação de níveis.
• Não usar factor para campos de valor único ou que não são categorias.

# Vetor de caracteres e vetor categórico.
eye_col <- c("brown", "green", "brown", "blue", "blue", "blue")
eye_col_f <- factor(eye_col)
eye_col
eye_col_f

levels(eye_col_f) # Valores distintos da variável categórica.

# Coerção.
as.numeric(eye_col)     # Produz NA.

## Warning: NAs introduced by coercion

as.numeric(eye_col_f)   # Números da tabela de correspondência.
as.character(eye_col_f) # Volta para caracteres.

• A matriz tem tipo de valor homogêneo, i.e. todos os elementos do mesmo tipo de valor.
• Muitas funções são getters e setters.
• getters (to get): extrai/consulta conteúdo.
• setters (to set): atribui/modifica conteúdo.

# Matriz a partir de vetor.
m <- rep(1, 20)   # Vetor cheio de 1.
dim(m) <- c(5, 4) # Atribui dimensões de eixos -> coerção para matriz.

# Criação usando a construtora `matrix()`.
m <- matrix(data = 1, nrow = 5, ncol = 4)  # Resulta no mesmo de antes.
dim(m)

# Matriz por concatenação de vetores.
m <- cbind(1:5, 5:1, 5:9)  # Concatenação por colunas.
m <- rbind(1:5, 5:1, 5:9)  # Concatenação por linhas.

# Seleção de eixos e elementos de matrizes.
m <- matrix(1:10, 10, 10)
m[2, 3]     # O elemento na posição 2·3.
m[2, ]      # Linha 2.
m[, 2]      # Coluna 2.
m[1:2, 4:6] # Submatrix.
m[-1, ]     # Exclui linha 1.

m[1, ] == m[, 1]
m > 3
m[m > 3]

t(m)          # Transposta de `m`.
m %*% t(m)    # Multiplicação matricial.
m * m         # Multiplicação elemento a elemento.

• São usados quando tem mais de duas dimensões.
• Arranjos de duas dimensões são matrizes.
• Arranjos também são de tipo homogêneo de valor.

a <- array(data = 1:18, dim = c(3, 3, 2))
a

## , , 1
## 
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9
## 
## , , 2
## 
##      [,1] [,2] [,3]
## [1,]   10   13   16
## [2,]   11   14   17
## [3,]   12   15   18

• A lista pode conter componentes de qualquer tipo de valor e classe.
• Listas podem conter listas e ter qualquer profundidade.
• É o tipo de estrutura mais geral.

# Uma lista de 4 componentes.
l1 <- list(boo = v1, foo = v2, moo = v3, zoo = "Animals!")
l2 <- list(v1, v2, v3, "Animals!")

# Criação de listas vazias.
l3 <- list()
l4 <- NULL

# Acessão componentes de uma lista.
l1["boo"]   # [ simples --> retorna lista com componente.
l1[["boo"]] # [ duplo --> retorna componente.
l1[1]       # idem mas com índices.
l1[[1]]     # [[ idem mas com índices.
l1$boo      # Mesmo uso do [[.

# Adição de conteúdo.
l3[[1]] <- 11        # Cria o primeiro elemento.
l4[[3]] <- c(22, 23) # Elementos 1 e 2 ficarão como NULL.

l1$Something <- "A thing" # Cria elemento nomeado.

c(l4, l3) # Concatena as listas.

## [[1]]
## NULL
## 
## [[2]]
## NULL
## 
## [[3]]
## [1] 22 23
## 
## [[4]]
## [1] 11

• A estrutura nativa do R para trabalhar com tabelas.
• Cada coluna é um vetor com seu tipo independente de valor.

dfr1 <- data.frame(ID = 1:4,
                   FirstName = c("John", "Jim", "Jane", "Jill"),
                   Female = c(FALSE, FALSE, TRUE, TRUE),
                   Age = c(22, 33, 44, 55))

dfr1$FirstName   # Acesso de variáveis igual a lista.
dfr1[["Female"]]

# Desfazendo o default que é converter caracteres para fatores.
dfr1$FirstName <- as.character(dfr1$FirstName)

str(dfr1) # Estrutura do objeto.

# Com [ é idem a seleção de eixos em matrizes.
dfr1[1, ]               # Tabela de uma linha.
dfr1[, 1]               # Vetor.
dfr1[, 1, drop = FALSE] # Tabela de uma coluna.
dfr1[1:2, 3:4]          # Subtabela.

# Com [[ é idem a seleção de listas.
dfr1$Age
dfr1[["Age"]]

dfr1[dfr1$Age > 30, ] # Filtro com vetor lógico.

# Estrutura IF ELSE.
x <- 5
y <- 10

if (x == 0) {
    y <- 0
} else {
    y <- y/x
}
y

## [1] 2

# Estrutura CASES
u <- "sim"
switch(u,
       "sim" = "Ela disse sim! :)",
       "não" = "Ela disse não. :(",
       "talvez" = "Não disse nem que sim nem que não. :|")

## [1] "Ela disse sim! :)"

# Estrutura de loop FOR.
ASum <- 0
AProd <- 1

for (i in 1:x) {
    ASum <- ASum + i
    AProd <- AProd * i
}

# Estrutura de loop WHILE.
while (x > 0) {
    print(x)
    x <- x - 1
}

# Estrutura de loop REPEAT.
repeat {
    print(x)
    x <- x + 1
    if (x > 10) {
        break
    }
}

baskara <- function(a, b, c) {
    stopifnot(c != 0)
    delta <- b^2 - 4 * a * c
    stopifnot(delta >= 0)
    r <- (-b * c(-1, 1) * sqrt(delta))/(2 * a)
    return(r)
}

# formals(baskara)
args(baskara)
body(baskara)

baskara(1, 1, -1)

## [1]  1.118034 -1.118034

f <- factor(c("A", "B", "C"))
class(f)

## [1] "factor"

methods(class = "factor")

##  [1] [             [[            [[<-          [<-           all.equal    
##  [6] as.character  as.data.frame as.Date       as.list       as.logical   
## [11] as.POSIXlt    as.vector     coerce        droplevels    format       
## [16] initialize    is.na<-       length<-      levels<-      Math         
## [21] Ops           plot          print         relevel       relist       
## [26] rep           show          slotsFromS3   summary       Summary      
## [31] xtfrm        
## see '?methods' for accessing help and source code

d <- Sys.Date()
class(d)

## [1] "Date"

methods(class = "Date")

##  [1] -             [             [[            [<-           +            
##  [6] as.character  as.data.frame as.list       as.POSIXct    as.POSIXlt   
## [11] Axis          c             coerce        cut           diff         
## [16] format        hist          initialize    is.numeric    julian       
## [21] length<-      Math          mean          months        Ops          
## [26] pretty        print         quarters      rep           round        
## [31] seq           show          slotsFromS3   split         str          
## [36] summary       Summary       trunc         weekdays      weighted.mean
## [41] xtfrm        
## see '?methods' for accessing help and source code

# Instala o pacote.
install.packages("tidyverse")

# Carrega o pacote.
library(tidyverse)

# Mostra conteúdo público do pacote.
ls("package:tidyverse")

# Descarrega o pacote.
detach("package:tidyverse")

# Mostra informações da sessão de trabalho.
sessionInfo()

# Acessa a documentação.
help(package = "tidyverse")

• R Referece Card.
• Cartões de referência em rstudio.com
• Cartões de referência por RStudio::conf.