operadores

Os seguintes operadores matemáticos estão definidos em R:

Operador	Descrição	Exemplo
+	adição
–	subtração
*	multiplicação
/	divisão	3/2 = 1.5;
^ ou **	exponenciação	3^2 = 6, 2**3 = 8
%%	módulo	9 %% 2 = 1
%/%	divisão inteira	9 %/% 2 = 4

Os seguintes operadores lógicos estão definidos:

Operador	Descrição	Exemplo
<	menor que	5 < 7 = TRUE
<=	menor ou igual	3 <= 9 = TRUE
>	maior que	5 > 7 = FALSE
>=	maior ou igual	7 >= 7 = TRUE
==	igual	3 == 5 = FALSE
!=	diferente	3 != 5 = TRUE
!x	não x	!(7 < 3) = TRUE
x \| y	x ou y	c(T, T, F) & c(T, F, F) = (T, T, F)
x \|\| y	ou (apenas 1º elemento examinado)	c(T, F, F) \|\| c(F, F, F) = TRUE
x & y	x e y	c(T, T, F) & c(T, F, F) = (T, F, F)
x & y	e (apenas 1º elemento examinado)	c(T, F, F) && c(F, F, F) = FALSE
isTRUE(x)	verifica se x é TRUE	isTRUE(7 < 9) = TRUE

Outros operadores:

Operador	Descrição	Exemplo
: (dois pontos)	cria uma sequência de números	2:6 = (2, 3, 4, 5, 6)
%in%	pertence	3 %in% 1:4 = TRUE,5 %in% 1:4 = FALSE
*%%**	multiplicação de matrizes por sua transposta	A %*% t(A)
any(condição sobre x)	TRUE se algum elemento de x satisfaz a condição	any(x==9)
all(condição sobre x)	TRUE se todos os elementos de x satisfazem a condição	all(x!=9)

Nos elementos de um vetor as operações ocorrem entre componentes de mesma posição em cada vetor.

> # Usando dois vetores de mesmo comprimento
> u <- c(1,2,3,4,5) > v <- c(5,4,3,2,1) > u+v
[1] 6 6 6 6 6
> u-v
[1] -4 -2  0  2  4
> u*v
[1] 5 8 9 8 5
> u**v
[1]  1 16 27 16  5
> u %% v
[1] 1 2 0 0 0
> u %/% v
[1] 0 0 1 2 5
> media <- (u + v) / 2 > media
[1] 3 3 3 3 3

> # Se os operandos têm comprimentos diferentes então um deve
> # ter comprimento múltiplo do outro. n cópias do vetor menor
> # serão usadas na operação e o resultado terá o tamanho do maior.
> u + c(1,2,3)
[1] 2 4 6 5 7
Warning message:
In u + c(1, 2, 3) :
  longer object length is not a multiple of shorter object length
> u + 10
[1] 11 12 13 14 15
> w <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) > u+w
 [1]  2  4  6  8 10  7  9 11 13 15
 w/u
[1]  1.000000 1.000000 1.000000 1.000000 1.000000
[6]  6.000000 3.500000 2.666667 2.250000 2.000000

># Lembrando que u = (1,2,3,4,5)
> any(u > 4)
[1] TRUE
> any(u > 5)
[1] FALSE
> all(u < 4)
[1] FALSE

Comparações lógicas entre vetores também são efetuadas entre elementos, um a um.

> u > v
[1] FALSE FALSE FALSE  TRUE  TRUE
> x <- 1:10 > x
 [1]  1  2  3  4  5  6  7  8  9 10
> x[x < 3 | x > 7]
[1]  1  2  8  9 10
> x[x > 2 & x < 8] [1] 3 4 5 6 7 >
> # O operador %in% busca valores entre todos de um vetor
> # Lembrando que u = (1, 2, 3, 4, 5)
> 1 %in% u
[1] TRUE
> 6 %in% u
[1] FALSE

Lembrando que x = 1:10, vamos verificar com maior detalhe a operação:

    x[x < 3 | x > 7] = (1, 2, 8, 9, 10)
Por partes:
    x < 3 = (T, T, F, F, F, F, F, F, F, F)
    x > 7 = (F, F, F, F, F, F, F, T, T, T)
    x < 3 | x > 7 = (T, T, F, F, F, F, F, T, T, T)
Finalmente
    x[(T, T, F, F, F, F, F, T, T, T)] = (1, 2, 8, 9, 10)
Portanto selecionamos os componentes do vetor x que são menores que 3 ou maiores que 7.

Operações pode ser realizadas entre membros de outros objetos compostos. Por exemplo, usando um data frame:

> mdata<-data.frame(x = c(2, 2, 6, 4), y = c(3, 4, 2, 8)) > mdata
   x  y
1  2  3
2  2  4
3  6  2
4  4  8
> attach(mdata)
> mdata$soma <- x + y > mdata$media <- (x + y)/2 > detach(mdata)
> # As operações acima acrescentaram dois novos campos à mdata:
> mdata
   x  y  soma  media
1  2  3    5   2.5
2  2  4    6   3.0
3  6  2    8   4.0
4  4  8   12   6.0
> # O mesmo tipo de operação pode ser feita de forma
> # alternativa usando-se a função transform
> valores <- data.frame(x=c(1,4,6,8), y=c(1,3,5,7))
> valores <- transform(valores, soma = x+y, media = (x+y)/2, teste = x>y)
> valores
  x y soma media teste
1 1 1    2   1.0 FALSE
2 4 3    7   3.5  TRUE
3 6 5   11   5.5  TRUE
4 8 7   15   7.5  TRUE

Funções internas

Quase toda a funcionalidade do R é obtida através de funções. Um grande número delas faz parte do bloco básico, carregado por default, e muitas outras podem ser utilizadas através da instalação de pacotes (packages).

Funções numéricas

Função	Descrição
abs(x)	$\left\|x\right\|$, valor absoluto
sqrt(x)	$\sqrt x$, raiz quadrada
ceiling(x)	menor inteiro acima: ceiling(3.475) = 4
floor(x)	maior inteiro abaixo: floor(3.475) = 3
trunc(x)	truncamento: trunc(5.99) is 5
round(x, digits=n)	arredondamento: round(3.475, digits=2) = 3.48
signif(x, digits=n)	n dígitos significantes: signif(3.475, digits=2) = 3.5
cos(x), sin(x), tan(x)	funções trigonométricas, seno, cosseno, tangente
acos(x), cosh(x), acosh(x)	outras funções trigonométricas
log(x)	$\ln(x)$ logaritmo natural (base e)
log10(x)	$\log(x)$, logaritmo de base 10
exp(x)	$e^x$, exponencial

Funções de texto

Função	Descrição
substr(x, a, b)	retorna ou substitui parte de uma string x, da posição a até b.
sub(texto1, texto2, x)	substitui, na string x, o texto1 pelo texto2.
grep(padrao, x , ignore.case=FALSE, fixed=FALSE)	Procura padrao em x. Se fixed = FALSE o padrão é uma expressão regular, caso contrário um texto simples. Retorna índice de localização.
strsplit(x, sep)	Quebra o vetor x em sep.
paste(…, sep=”-“)	Concatena strings usando a string sep como separador.
paste(…, collapse=”-“)	Monta uma única string com partes do argumento, usando collapse como separador.
toupper(x)	retorna texto em letras maiúsculas
tolower(x)	retorna texto em letras minúsculas
nchar(x)	retorna o comprimento da string x

> # Retornar uma substring
> substr("abcdef",3,5)
[1] "cde"
> cores <- c("azul escuro", "verde escuro", "preto")
> substr(cores, 1, 5)
[1] "azul " "verde" "preto"
> # Substituir caracteres
> sub("strings", "texto", "Trocar strings")
[1] "Trocar texto"
> # A substituição pode ser feita em todos os componentes do vetor
> sub("escuro", "claro", cores)
[1] "azul claro"  "verde claro" "preto"

> # Partir texto
> strsplit("as casas de maria", " ")
[[1]]
[1] "as"  "casas"  "de"  "maria"
> strsplit("ABCDEF", "BC")
[[1]]
[1] "A"   "DEF"
> strsplit("ABCDEF", "")
[[1]]
[1] "A" "B" "C" "D" "E" "F"
> # As funções agem em todos os comonentes do objeto
> x <- c("estudar", "R", "no site") > substr(x,1,2)
[1] "es" "R"  "no"

> # Uso se expressão regular
> s <- "www.phylos.net" > sub("p.+s","filosofia", s)
[1] "www.filosofia.net"

> toupper("falando alto")
[1] "FALANDO ALTO"
> tolower("Não GRITE")
[1] "não grite"

> # Para juntar strings:
> paste("primeiro", "segundo", "terceiro")
[1] "primeiro segundo terceiro"
> paste("primeiro", "segundo", "terceiro", sep = ", ")
[1] "primeiro, segundo, terceiro"
> # Valores numéricos são convertidos em strings
> paste(1,2,3, sep="-")
[1] "1-2-3"
> paste(1,2,3, sep="")
[1] "123"
> paste("tentativa", 1)
[1] "tentativa 1"
> tent <- paste("tentativa", 1:5) > tent[5]
[1] "tentativa 5"

Funções Auxiliares Úteis

Função	Descrição
seq(from, to, by)	gera sequência numérica (início, fim, passo)
rep(x, times=n)	repete x n vezes
cut(x, n)	divide variável contínua (numérica) em fator com n níveis
pretty(x,n)	divide variável contínua em n intervalos
cat(… , file = `nomeArquivo`, append = FALSE)	concatena objectos em …e os envia para o console ou arquivo `nomeArquivo` (se existir)

> seq(12, 30, 2)
[1] 12 14 16 18 20 22 24 26 28 30
> # Forçando o resultado a ter 5 elementos
> seq(from=0, to=20, length.out=5)
[1]  0  5 10 15 20

> rep("ha", times=4)
[1] "ha" "ha" "ha" "ha"
> # Repetindo cada elemento n vezes
> rep(c(1,2,3), each=2)
[1] 1 1 2 2 3 3
> $ Repete o primeiro elemento 4 x, o segundo 2 x
> rep(c("a", "b"), times = c(4,2))
[1] "a" "a" "a" "a" "b" "b"

> # cut permite a criação de fator. Abaixo, com 4 níveis:
> idades <- c(12, 14, 16, 17, 34, 32, 12, 12, 11) > cut(idades, breaks=4)
[1] (11,16.8]   (11,16.8]   (11,16.8]   (16.8,22.5] (28.2,34]
[5] (28.2,34]   (11,16.8]   (11,16.8]   (11,16.8]
Levels: (11,16.8] (16.8,22.5] (22.5,28.2] (28.2,34]
> # Uso de pretty
> pretty(1:20, n=2)
[1]  0 10 20
> pretty(1:20, n=10)
[1]  0  2  4  6  8 10 12 14 16 18 20
> # Uso de cat
> nome <- "Ana" > cat("Olá",nome,"\b.\n", "\t \"Bom dia!\"")
Olá Ana.
 	 "Bom dia!"

Usamos na linha de demonstração de cat() usamos as sequências de escape \n (newline), \b (backspace), \t (tab), \" (aspas duplas)

Funções úteis para a manipulação de Objetos

Listamos em seguida algumas das funções importantes para a leitura e edição de objetos.

Função	Descrição
length(obj)	retorna o número de elementos ou componentes do objeto
dim(obj)	retorna as dimensões do objeto.
str(obj)	exibe a estrutura do objeto.
head()	lista os seis primeiros elementos do objeto
tail()	lista os seis últimas elementos do objeto
class(obj)	retorna a classe do objeto.
mode(obj)	exibe como o objeto foi armazenado
names(obj)	exibe os nomes de componentes do objeto
c(obj₁, …, obj_n)	concatena objetos em um vector
cbind(obj₁, …, obj_n)	combina objetos em colunas
rbind(obj₁, …, obj_n)	combina objetos em linhas
obj, print(obj)	exibe / imprime objeto.
head(obj)	lista a primeira parte do objeto
tail(obj)	lista a parte final do objeto
ls()	exibe lista dos objetos carregados, equivalenta à função objects()
rm(obj₁, …, obj_n)	remove um ou mais objetos
rm(list = ls())	)remove todos os objetos
novoObj <- edit(obj)	edita objeto e o armazena como novoObj
fix(obj)	edita objeto salvando nele as alterações

Data e Hora

Datas são armazenadas internamente no R como o número de dias decorridos desde 01/01/1970. Datas anteriores são representadas como números negativos.

Função	Descrição
as.Date(string)	converte a string em uma data
Sys.Date( )	retorna a data de hoje
date()	retorna data e hora corrente
data₂ – data₁	retorna a diferença entre data₁ e data₂ em dias
as.character(data)	retorna a data como um string
format(data, format=strDeFormato)	formata a data segundo o string de formatação
weekdays(data)	dia da semana correspondente a data (ou datas)
months(data)	mês não abreviado correspondente a data (ou datas)
quarters(data)	Quarter (Q1, Q2, Q3, Q4)
seq(from=data₁, to=data₂, by=n)	sequência de datas de data₁ até data₂, em passos n (dias)

> # Data do sistema (um string, formato ano/mês/dia)
> Sys.Date()
[1] "2018-11-23"
> # Transforma esta string em uma data
> data1 <- as.Date(Sys.Date()) > # Soma 250 dias à data1
> data2 <- data1 + 250 > data2 - data1
[1] Time difference of 250 days
> # Sequência de datas começando em data1 até data2 com passos de 50 dias
> seq(from=data1, to=data2, by=50)
[1] "2018-11-23" "2019-01-12" "2019-03-03"
[4] "2019-04-22" "2019-06-11" "2019-07-31"
> # Produz sequência de datas de data1 até data2 com 5 elementos
> seq(from=data1, to=data3, length.out=5)
[1] "2018-11-23" "2019-01-24" "2019-03-28"
[4] "2019-05-29" "2019-07-31"
> weekdays(data1)
[1] "sexta"
> months(data1)
[1] "novembro"
> quarters(data1)
[1] "Q4"
> format(data1, "%d/%m/%y")
[1] "23/11/18"
> format(data1, "%d/%m/%Y")
[1] "23/11/2018"
> format(data1, "%A, %d de %B de %Y")
[1] "sexta, 23 de novembro de 2018"
> # As funções se aplicam a vetores e outros objetos
> strData <- c("01/05/1965", "08/16/1975")
> datas <- as.Date(strDatas, "%m/%d/%Y") > datas
[1] "1965-01-05" "1975-08-16"
> Para lidar com o formato brasileiro de dia/mes/ano podemos fazer
> dBr <- as.Date("23/11/2018", "%d/%m/%Y") > dBr
[1] "2018-11-23"

Os seguintes símbolos (ou máscaras) podem ser usados com datas. Os resultados dependem das configurações de data/hora locais, que podem ser visualizadas com o comando Sys.localeconv().

Símbolo	Descrição	Exemplo
%d	dia, numérico	01 a 31
%a	dia da semana, abreviado	Mon, (Seg)
%A	dia da semana por extenso	Monday (segunda)
%m	mês, numérico	01 a 12
%b	nome do mês, abreviado	Feb, (Fev)
%B	nome do mês por extenso	February, (Fevereiro)
%y	ano em 2 dígitos	18
%Y	ano em 4 dígitos	2018

Funções Estatísticas

Função	Descrição
mean(x, trim=0,na.rm=FALSE)	média do objeto x
sd(x)	desvio padrão do objeto x
var(x)	variância
mad(x)	desvio absoluto médio
median(x)	mediana
quantile(x, probs)	quantil de x, probs= vetor numérico com probabilidades em [0,1]
range(x)	intervalo
sum(x)	soma
diff(x, lag=1)	diferenças defasadas, lag = defasagem a usar
min(x)	mínimo de x
max(x)	máximo de x
scale(x, center=TRUE, scale=TRUE)	centro da coluna ou padronizar uma matriz

> x <- c(123, 234, 345, 242, 34, 100, NA)
> mean(x)
[1] NA
> # mesma operação ignorando valor NA
> mean(x, na.rm=TRUE)
[1] 179.6667
> # redefinindo x
> x <- c(123, 234, 345, 242, 34, 100)
> sum(x)
[1] 1078
> range(x)
[1]  34 345
> min(x)
[1] 34
> max(x)
[1] 345
> mean(x)
[1] 179.6667
> # Eliminando valores 20% nas bordas da amostra
> mean(x, trim=.2)
[1] 174.75
> sd(x)
[1] 113.9731
> var(x)
[1] 12989.87
> mad(x)
[1] 105.2646
> median(x)
[1] 178.5

A tabela seguinte lista funções relacionadas com distribuições probabilísticas. Para gerar sequências pseudo-randômicas (que podem ser replicadas mais tarde) use set.seed(1234) (ou outro inteiro).

Função	Descrição
dbinom(x, size, prob) pbinom(q, size, prob) qbinom(p, size, prob) rbinom(n, size, prob)	distribuição binomial, onde size = tamanho da amostra e prob é probabilidade de sucesso em cada experimento.
dpois(x, lambda) ppois(q, lambda) qpois(p, lambda) rpois(n, lambda)	Distribuição de Poisson com m=std=lambda
dunif(x, min=0, max=1) punif(q, min=0, max=1) qunif(p, min=0, max=1) runif(n, min=0, max=1)	Distribuição uniforme, segue mesmo padrão que a distribuição normal acima.

Voltaremos ao estudos destas funções mais tarde.

A Distribuição Normal

Por completeza listamos aqui algumas funções de distribuição de probabilidades. As funções de densidade, de distribuição, quantil e a geração aleatória para a distribuição normal podem ser obtidas com média e desvio padrão especificados.

A função rnorm gera dados aleatórios com distribuição normal:

    dnorm(x, mean = 0, sd = 1, log = FALSE)
    pnorm(q, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)
    qnorm(p, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)
    rnorm(n, mean = 0, sd = 1)

São argumentos:

x, q	vetor de quantils.
p	vetor de probabilidades.
n	número de observações. Se length(n) > 1, the length is taken to be the number required.
mean	vetor de médias.
sd	vetor de desvios padrão.
log, log.p	logical; se TRUE, probabilidades são dadas como log(p).
lower.tail	logical; se TRUE (default), probabilidades são P[X ≤ x]; caso contrário, P[X > x].

Se a média e o desvio padrão não são especificados eles assumem o valor default 0 e 1, respectivamente.

A distribuição normal tem densidade:

$$
f(x) = \frac{1}{\sigma \sqrt{2\pi}} \text{e}^{-\frac{(x-\mu)^2}{2\sigma ^2}}
$$

onde $\mu$ é a média da distribuição e $\sigma$ é o desvio padrão.

dnorm fornece a densidade, pnorm a função de distribuição, qnorm a função quantil, rnorm gera os desvios aleatórios. O comprimento do resultado é determinado por n para rnorm. Para as demais funções ele é igual ao maior comprimento dos argumentos numéricos.

Os argumentos numéricos (exceto de n) são reciclados para o tamanho do resultado. Apenas os primeiros elementos dos argumentos lógicos são usados.

> x <- pretty(c(-3,3), 100)
> y <- dnorm(x)
> plot(x, y, type = "l", xlab = "Desvio Normal", ylab = "Densidade")

Este código gera o gráfico exibido à direita. Veremos em breve maiores detalhes sobre o uso da função plot() usada para gerar o gráfico.

A distribuição normal é uma das mais utilizadas na modelagem dos fenômenos naturais e das ciências naturais e sociais. Ela é também chamada de distribuição de Gauss ou de Laplace–Gauss, em referência aos matemáticos Pierre-Simon Laplace (1749-1827) e Carl Friedrich Gauss (1777-1855).

Controle de Fluxo e Funções do Usuário

Phylos.net

Pensar e Imaginar