Aula 16 – Curso de R – Operadores em R

toticavalcanti

Aula 16 – Curso de R – Operadores em R

Convertendo objetos

Página principal do blog

Todas as aulas desse curso

Aula 15 Aula 17

Antes, quero deixar meus links de afiliados pra vocês:

Hostinger

One.com

DigitalOcean

Se cadastrando, vocês poderão conhecer, usar e testar gratuitamente alguns recursos dos serviços oferecidos por eles.

Por favor, se gostarem do conteúdo dêem um joinha 👍, curtam e compartilhem a página do Código Fluente no Facebook.

Endereço para baixar os arquivos e o script:

https://github.com/toticavalcanti/curso_r

Operadores em R

Existem 3 tipos de operadores, como em outras linguagens.

Aritméticos	Comparações	Lógicos
+ adição	< menor que	! x NOT
– subtração	> maior que	x & y AND
* multiplicação	<= menor igual	x && y id.
/ divisão	>= maior igual	x \| y OR
^ potência	== igual	x \|\| y id.
%% módulo	!= diferente	xor(x, y) OR exclusivo
%/% divisão inteira

Os operadores aritméticos e de comparação atuam em dois elementos (x + y, a < b).

Os operadores aritméticos atuam não apenas em variáveis de modo numérico ou complexo, mas também em variáveis lógicas.

Nelas, os valores lógicos são transformados em numéricos.

Os operadores de comparação podem ser aplicados a qualquer modo: eles retornam um ou vários valores lógicos.

Os operadores “E” e “OU” existem em duas formas:

Único: & ou | que opera em cada elemento e retorna tantos valores lógicos quanto as comparações feitas.
Duplo: && ou || que opera só no primeiro elemento dos objetos.

Vamos a alguns exemplos.


x <- c(TRUE,FALSE,TRUE)
y <- c(FALSE,TRUE,TRUE)
x
#Saída: [1]  TRUE FALSE  TRUE


x | y
#Saída: [1]  TRUE TRUE TRUE

x || y
#Saída: [1] TRUE


x & y
#Saída: [1] FALSE FALSE  TRUE

x && y
#Saída: [1] FALSE

Podemos aplicar aos operadores lógicos um (! – NOT) ou dois objetos de modo lógico e retornar um (ou vários) valores lógicos.


b <- TRUE
!b
#Saída: [1] FALSE

É necessário usar o operador “AND” para especificar uma desigualdade do tipo 0 < x < 1 que será codificado assim:

0 < x & x < 1

A expressão 0 < x < 1 é válida, mas, não retornará o resultado esperado, já que ambos os operadores são iguais e são executados sucessivamente da esquerda para a direita.

A comparação 0 < x é feito primeiro e retorna um valor lógico que é então comparado com 1 (TRUE or FALSE < 1).

Nesta situação, o valor lógico é implicitamente convertido em numérico (1 ou 0 <1).

Exemplo:


x <- 0.5
0 < x < 1
#Saída: [1] FALSE

Os operadores de comparação operam em cada elemento dos dois objetos comparados (reciclando os valores do mais curto, se necessário), e portanto, retornam um objeto do mesmo tamanho.

Para comparar “totalmente” dois objetos, duas funções estão disponíveis: identical() e all.equal().


x <- 1:3; y <- 1:3
x == y
#Saída: [1] TRUE TRUE TRUE
identical(x, y)
#Saída: [1] TRUE

all.equal(x, y)
#Saída: [1] TRUE

A identical() compara a representação interna dos dados e retorna TRUE se os objetos são idênticos e FALSE caso contrário.

A all.equal() compara o quão igual são dois objetos e retorna TRUE ou mostra um resumo das diferenças.

Ela leva em consideração a aproximação no processo de cálculo da computação ao comparar valores numéricos.

A comparação de valores numéricos em computação às vezes pode surpreender!

Exemplos:


0.9 == (1 - 0.1)
#Saída: [1] TRUE

identical(0.9, 1 - 0.1)
#Saída: [1] TRUE

all.equal(0.9, 1 - 0.1)
#Saída: [1] TRUE

0.9 == (1.1 - 0.2)
#Saída: [1] FALSE

identical(0.9, 1.1 - 0.2)
#Saída: [1] FALSE

all.equal(0.9, 1.1 - 0.2)
#Saída: [1] TRUE

all.equal(0.9, 1.1 - 0.2, tolerance = 1e-16)
#Saída: [1] "Mean relative difference: 1.233581e-16"