R – 运算符

运算符是指示编译器在操作数之间执行各种操作的符号。运算符模拟对一组复数、整数和数值执行的各种数学、逻辑和决策运算作为输入操作数。

R 运算符

R 在一组操作数之间主要支持四种二元运算符。在本文中，我们将看到R 编程语言中各种类型的运算符及其用法。

R语言中的运算符类型

• 算术运算符
• 逻辑运算符
• 关系运算符
• 赋值运算符
• 杂项运算符

算术运算符

算术运算使用操作数之间的指定运算符模拟各种数学运算，例如加法、减法、乘法、除法和取模，操作数可以是标量值、复数或向量。这些操作在向量的相应位置逐元素执行。

加法运算符(+)：

两个操作数对应位置的值相加。考虑以下 R 片段来添加两个向量：

Input : a <- c (1, 0.1)
        b <- c (2.33, 4)
        print (a+b)
Output : 3.33  4.10 

减法运算符 (-)：

从第一个中减去第二个操作数值。考虑以下 R 片段来减去两个变量：

Input : a <- 6
        b <- 8.4
        print (a-b)
Output : -2.4 

乘法运算符 (*)：

向量和整数的对应元素的乘法使用 '*'运算符相乘。

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. 

除法运算符 (/)：

使用“/”运算符将第一个操作数除以第二个操作数。

Input : a <- 1
        b <- 0
        print (a/b)
Output : -Inf

电源运算符 (^)：

第一个操作数是第二个操作数的幂。

Input : list1 <- c(2, 3)
        list2 <- c(2,4)
        print(list1^list2)
Output : 4  81

模运算符 (%%):

返回第一个操作数除以第二个操作数的余数。

Input : list1<- c(2, 3)
        list2<-c(2,4)
        print(list1%%list2)
Output : 0  3

以下 R 代码说明了 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)

输出：

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

逻辑运算符

逻辑运算基于操作数之间的指定运算符模拟逐元素决策运算，然后将其评估为 True 或 False 布尔值。任何非零整数值都被视为 TRUE 值，无论是复数还是实数。

逐元素逻辑与运算符(&)：

如果两个操作数都为 True，则返回 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. 

逐元素逻辑或运算符(|)：

如果任一操作数为 True，则返回 True。

Input : list1 <- c(TRUE, 0.1)
        list2 <- c(0,4+3i)
        print(list1|list2)
Output : TRUE  TRUE

非运算符（！）：

否定操作数元素状态的一元运算符。

Input : list1 <- c(0,FALSE)
        print(!list1)    
Output : TRUE  TRUE

逻辑与运算符(&&)：

如果操作数的第一个元素都为 True，则返回 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.

逻辑或运算符(||)：

如果操作数的第一个元素中的任何一个为 True，则返回 True。

Input : list1 <- c(TRUE, 0.1)
        list2 <- c(0,4+3i)
        print(list1||list2)
Output : TRUE 

以下 R 代码说明了 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)

输出：

Element wise AND : FALSE FALSE 
Element wise OR : TRUE TRUE 
Logical AND : FALSE 
Logical OR : TRUE 
Negation : TRUE FALSE

关系运算符

关系运算符在操作数的对应元素之间执行比较操作。如果第一个操作数满足与第二个相比的关系，则返回布尔 TRUE 值。 TRUE 值始终被认为大于 FALSE。

小于 (<)：

如果第一个操作数的对应元素小于第二个操作数的对应元素，则返回 TRUE。否则返回 FALSE。

Input :  list1 <- c(TRUE, 0.1,"apple")
         list2 <- c(0,0.1,"bat")
         print(list1

小于等于 (<=)：

如果第一个操作数的相应元素小于或等于第二个操作数的相应元素，则返回 TRUE。否则返回 FALSE。

Input :  list1 <- c(TRUE, 0.1,"apple")
         list2 <- c(0,0.1,"bat")
         print(list<=list2)
Output : FALSE TRUE TRUE

大于 (>)：

如果第一个操作数的对应元素大于第二个操作数的对应元素，则返回 TRUE。否则返回 FALSE。

Input :  list1 <- c(TRUE, 0.1,"apple")
         list2 list2)
Output : TRUE FALSE FALSE

大于等于 (>=)：

如果第一个操作数的相应元素大于或等于第二个操作数的相应元素，则返回 TRUE。否则返回 FALSE。

Input :  list1 <- c(TRUE, 0.1,"apple")
         list2 =list2)
Output : TRUE TRUE FALSE

不等于 (!=)：

如果第一个操作数的对应元素不等于第二个操作数，则返回 TRUE。否则返回 FALSE。

Input : list1 <- c(TRUE, 0.1,""apple")
        list2 <- c(0,0.1,"bat")
        print(list1!=list2)
Output : TRUE FALSE TRUE

以下 R 代码说明了 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")

输出：

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 

赋值运算符

赋值运算符用于为 R 中的各种数据对象赋值。对象可以是整数、向量或函数。这些值然后由分配的变量名称存储。有两种赋值运算符：左和右

左分配（<- 或 <<- 或 =）：

为向量赋值。

Input : vec1 = c("ab", TRUE) 
        print (vec1)
Output : "ab"   "TRUE"

右分配（-> 或 ->>）：

为向量赋值。

Input : c("ab", TRUE) ->> vec1
        print (vec1)
Output : "ab"   "TRUE"

以下 R 代码说明了 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)

输出：

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

杂项运算符

这些是模拟序列打印和向量分配的混合运算符，无论是左手还是右手。

%in% 运算符：

检查元素是否属于列表，如果值存在则返回布尔值 TRUE，否则返回 FALSE。

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.

冒号运算符(:)：

打印从颜色之前的元素开始到之后的元素的元素列表。

Input :  print (1:5)
Output : 1 2 3 4 5
Prints a sequence of the numbers from 1 to 5.

％*％ 操作员：

该运算符用于将矩阵与其转置相乘。矩阵的转置是通过将行交换为列和将列交换为行来获得的。第一个矩阵的列数必须等于第二个矩阵的行数。矩阵 A 与其转置 B 相乘，产生一个方阵。
$A_{r*c} x B_c*r -> P_{r*r}$

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

以下 R 代码说明了 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)

输出：

[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