Los operadores son los símbolos que indican al compilador que realice varios tipos de operaciones entre los operandos. Los operadores simulan las diversas operaciones matemáticas, lógicas y de decisión realizadas en un conjunto de números complejos, enteros y numéricos como operandos de entrada.
Operadores R
R admite principalmente cuatro tipos de operadores binarios entre un conjunto de operandos. En este artículo, veremos varios tipos de operadores en el lenguaje de programación R y su uso.
Tipos del operador en lenguaje R
- Operadores aritméticos
- Operadores logicos
- Operadores relacionales
- Operadores de Asignación
- Operador misceláneo
Operadores aritméticos
Las operaciones aritméticas simulan varias operaciones matemáticas, como suma, resta, multiplicación, división y módulo utilizando el operador especificado entre operandos, que pueden ser valores escalares, números complejos o vectores. Las operaciones se realizan por elementos en las posiciones correspondientes de los vectores.
Operador de suma (+):
Se suman los valores en las posiciones correspondientes de ambos operandos. Considere el siguiente fragmento de R para agregar dos vectores:
Input : a <- c (1, 0.1)
b <- c (2.33, 4)
print (a+b)
Output : 3.33 4.10
Operador de resta (-):
Los valores del segundo operando se restan del primero. Considere el siguiente fragmento de R para restar dos variables:
Input : a <- 6
b <- 8.4
print (a-b)
Output : -2.4
Operador de multiplicación (*):
La multiplicación de elementos correspondientes de vectores y enteros se multiplica con el uso del operador ‘*’.
Input : B= matrix(c(4,6i),nrow=1,ncol=2)
C= matrix(c(2,2i ),nrow=1, ncol=2)
print (B*C)
Output : 8+0i -12+0i
The elements at corresponding positions of matrices are multiplied.
Operador de división (/):
El primer operando se divide por el segundo operando con el uso del operador ‘/’.
Input : a <- 1
b <- 0
print (a/b)
Output : -Inf
Operador de energía (^):
El primer operando se eleva a la potencia del segundo operando.
Input : list1 <- c(2, 3)
list2 <- c(2,4)
print(list1^list2)
Output : 4 81
Operador de módulo (%%):
Se devuelve el resto del primer operando dividido por el segundo operando.
Input : list1<- c(2, 3)
list2<-c(2,4)
print(list1%%list2)
Output : 0 3
El siguiente código R ilustra el uso de todos los operadores aritméticos en R:
R
# R program to illustrate
# the use of Arithmetic operators
vec1 <- c(0, 2)
vec2 <- c(2, 3)
# Performing operations on Operands
cat ("Addition of vectors :", vec1 + vec2, "\n")
cat ("Subtraction of vectors :", vec1 - vec2, "\n")
cat ("Multiplication of vectors :", vec1 * vec2, "\n")
cat ("Division of vectors :", vec1 / vec2, "\n")
cat ("Modulo of vectors :", vec1 %% vec2, "\n")
cat ("Power operator :", vec1 ^ vec2)
Producción:
Addition of vectors : 2 5 Subtraction of vectors : -2 -1 Multiplication of vectors : 0 6 Division of vectors : 0 0.6666667 Modulo of vectors : 0 2 Power operator : 0 8
Operadores logicos
Las operaciones lógicas simulan operaciones de decisión por elementos, en función del operador especificado entre los operandos, que luego se evalúan como un valor booleano verdadero o falso. Cualquier valor entero distinto de cero se considera un valor VERDADERO, ya sea un número complejo o real.
Operador AND lógico por elementos (&):
Devuelve True si ambos operandos son True.
Input : list1 <- c(TRUE, 0.1)
list2 <- c(0,4+3i)
print(list1 & list2)
Output : FALSE TRUE
Any non zero integer value is considered as a TRUE value, be it complex or real number.
Operador OR lógico por elementos (|):
Devuelve True si alguno de los operandos es True.
Input : list1 <- c(TRUE, 0.1)
list2 <- c(0,4+3i)
print(list1|list2)
Output : TRUE TRUE
NO operador (!):
Un operador unario que niega el estado de los elementos del operando.
Input : list1 <- c(0,FALSE)
print(!list1)
Output : TRUE TRUE
Operador lógico AND (&&):
Devuelve True si los dos primeros elementos de los operandos son True.
Input : list1 <- c(TRUE, 0.1)
list2 <- c(0,4+3i)
print(list1 && list2)
Output : FALSE
Compares just the first elements of both the lists.
Operador OR lógico (||):
Devuelve True si alguno de los primeros elementos de los operandos es True.
Input : list1 <- c(TRUE, 0.1)
list2 <- c(0,4+3i)
print(list1||list2)
Output : TRUE
El siguiente código R ilustra el uso de todos los operadores lógicos en R:
R
# R program to illustrate
# the use of Logical operators
vec1 <- c(0,2)
vec2 <- c(TRUE,FALSE)
# Performing operations on Operands
cat ("Element wise AND :", vec1 & vec2, "\n")
cat ("Element wise OR :", vec1 | vec2, "\n")
cat ("Logical AND :", vec1 && vec2, "\n")
cat ("Logical OR :", vec1 || vec2, "\n")
cat ("Negation :", !vec1)
Producción:
Element wise AND : FALSE FALSE Element wise OR : TRUE TRUE Logical AND : FALSE Logical OR : TRUE Negation : TRUE FALSE
Operadores relacionales
Los operadores relacionales realizan operaciones de comparación entre los elementos correspondientes de los operandos. Devuelve un valor booleano VERDADERO si el primer operando satisface la relación en comparación con el segundo. Un valor VERDADERO siempre se considera mayor que el FALSO.
Menos que (<):
Devuelve VERDADERO si el elemento correspondiente del primer operando es menor que el del segundo operando. De lo contrario, devuelve FALSO.
Input : list1 <- c(TRUE, 0.1,"apple")
list2 <- c(0,0.1,"bat")
print(list1<list2)
Output : FALSE FALSE TRUE
Menor que igual a (<=):
Devuelve VERDADERO si el elemento correspondiente del primer operando es menor o igual que el del segundo operando. De lo contrario, devuelve FALSO.
Input : list1 <- c(TRUE, 0.1,"apple")
list2 <- c(0,0.1,"bat")
print(list<=list2)
Output : FALSE TRUE TRUE
Mayor que (>):
Devuelve VERDADERO si el elemento correspondiente del primer operando es mayor que el del segundo operando. De lo contrario, devuelve FALSO.
Input : list1 <- c(TRUE, 0.1,"apple")
list2 list2)
Output : TRUE FALSE FALSE
Mayor que igual a (>=):
Devuelve VERDADERO si el elemento correspondiente del primer operando es mayor o igual que el del segundo operando. De lo contrario, devuelve FALSO.
Input : list1 <- c(TRUE, 0.1,"apple")
list2 =list2)
Output : TRUE TRUE FALSE
No es igual a (!=):
Devuelve VERDADERO si el elemento correspondiente del primer operando no es igual al segundo operando. De lo contrario, devuelve FALSO.
Input : list1 <- c(TRUE, 0.1,""apple")
list2 <- c(0,0.1,"bat")
print(list1!=list2)
Output : TRUE FALSE TRUE
El siguiente código R ilustra el uso de todos los operadores relacionales en R:
R
# R program to illustrate
# the use of Relational operators
vec1 <- c(0, 2)
vec2 <- c(2, 3)
# Performing operations on Operands
cat ("Vector1 less than Vector2 :", vec1 < vec2, "\n")
cat ("Vector1 less than equal to Vector2 :", vec1 <= vec2, "\n")
cat ("Vector1 greater than Vector2 :", vec1 > vec2, "\n")
cat ("Vector1 greater than equal to Vector2 :", vec1 >= vec2, "\n")
cat ("Vector1 not equal to Vector2 :", vec1 != vec2, "\n")
Producción:
Vector1 less than Vector2 : TRUE TRUE Vector1 less than equal to Vector2 : TRUE TRUE Vector1 greater than Vector2 : FALSE FALSE Vector1 greater than equal to Vector2 : FALSE FALSE Vector1 not equal to Vector2 : TRUE TRUE
Operadores de Asignación
Los operadores de asignación se utilizan para asignar valores a varios objetos de datos en R. Los objetos pueden ser números enteros, vectores o funciones. Estos valores luego son almacenados por los nombres de variables asignados. Hay dos tipos de operadores de asignación: Left y Right
Asignación izquierda (<- o <<- o =):
Asigna un valor a un vector.
Input : vec1 = c("ab", TRUE)
print (vec1)
Output : "ab" "TRUE"
Asignación de derecho (-> o ->>):
Asigna valor a un vector.
Input : c("ab", TRUE) ->> vec1
print (vec1)
Output : "ab" "TRUE"
El siguiente código R ilustra el uso de todos los operadores relacionales en R:
R
# R program to illustrate
# the use of Assignment operators
vec1 <- c(2:5)
c(2:5) ->> vec2
vec3 <<- c(2:5)
vec4 = c(2:5)
c(2:5) -> vec5
# Performing operations on Operands
cat ("vector 1 :", vec1, "\n")
cat("vector 2 :", vec2, "\n")
cat ("vector 3 :", vec3, "\n")
cat("vector 4 :", vec4, "\n")
cat("vector 5 :", vec5)
Producción:
vector 1 : 2 3 4 5 vector 2 : 2 3 4 5 vector 3 : 2 3 4 5 vector 4 : 2 3 4 5 vector 5 : 2 3 4 5
Operadores misceláneos
Estos son los operadores mixtos que simulan la impresión de secuencias y la asignación de vectores, ya sean diestros o zurdos.
Operador %in%:
Comprueba si un elemento pertenece a una lista y devuelve un valor booleano VERDADERO si el valor está presente o FALSO.
Input : val <- 0.1
list1 <- c(TRUE, 0.1,"apple")
print (val %in% list1)
Output : TRUE
Checks for the value 0.1 in the specified list. It exists, therefore, prints TRUE.
Operador de dos puntos (:):
Imprime una lista de elementos comenzando con el elemento anterior a los dos puntos hasta el elemento posterior.
Input : print (1:5) Output : 1 2 3 4 5 Prints a sequence of the numbers from 1 to 5.
%*% Operador:
Este operador se usa para multiplicar una array con su transpuesta. La transposición de la array se obtiene intercambiando filas por columnas y columnas por filas. El número de columnas de la primera array debe ser igual al número de filas de la segunda array. La multiplicación de la array A por su transpuesta B produce una array cuadrada. 
Input : mat = matrix(c(1,2,3,4,5,6),nrow=2,ncol=3)
print (mat)
print( t(mat))
pro = mat %*% t(mat)
print(pro)
Output : [,1] [,2] [,3] #original matrix of order 2x3
[1,] 1 3 5
[2,] 2 4 6
[,1] [,2] #transposed matrix of order 3x2
[1,] 1 2
[2,] 3 4
[3,] 5 6
[,1] [,2] #product matrix of order 2x2
[1,] 35 44
[2,] 44 56
El siguiente código R ilustra el uso de todos los operadores varios en R:
R
# R program to illustrate
# the use of Miscellaneous operators
mat <- matrix (1:4, nrow = 1, ncol = 4)
print("Matrix elements using : ")
print(mat)
product = mat %*% t(mat)
print("Product of matrices")
print(product,)
cat ("does 1 exist in prod matrix :", "1" %in% product)
Producción:
[1] "Matrix elements using : "
[,1] [,2] [,3] [,4]
[1,] 1 2 3 4
[1] "Product of matrices"
[,1]
[1,] 30
does 1 exist in prod matrix : FALSE