Operadores e Funções Internas

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 separator.
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"
> # Substituir caracteres
> sub("strings", "texto", "Trocar strings")
[1] "Trocar texto"
> # 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!"

Para exibir o comportamento 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 últimass 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(obj1, …, objn) concatena objetos em um vector
cbind(obj1, …, objn) combina objetos em colunas
rbind(obj1, …, objn) 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
rm(obj1, …, objn) 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
data2 – data1 retorna a diferença entre data1 e data2 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=data1, to=data2, by=n) sequência de datas de data1 até data2, 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")
Distribuição normal

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).


Funções do Usuário

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *