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
矩阵相应位置上的元素被乘以。

除法运算符（/）

通过使用’/’运算符，第一个操作数被第二个操作数除以。

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

Modulo操作符（%%）

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

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

下面的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

逻辑运算法则

逻辑运算模拟的是元素明智的决策运算，基于操作数之间的指定运算符，然后被评估为真或假的布尔值。任何非零的整数值都被认为是真值，无论是复数还是实数。

元素间逻辑和运算符（&）

如果操作数都是 “真”，则返回 “真”。

Input : list1 <- c(TRUE, 0.1)
list2 <- c(0,4+3i)
print(list1 & list2)
Output : FALSE TRUE
任何非零的整数值都被认为是真值，无论是复数还是实数。

元素-明智的逻辑OR运算符（|）

如果操作数中的任何一个为 “真”，则返回 “真”。

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

NOT运算符（！）

一个单数运算符，用于否定操作数中元素的状态。

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

Output : TRUE TRUE

逻辑和运算符（ &&）

如果操作数的第一个元素都是真，则返回真。

Input : list1 <- c(TRUE, 0.1)
list2 <- c(0,4+3i)
print(list1 && list2)
Output : FALSE
只比较两个列表的第一个元素。

逻辑OR运算符（||）

如果操作数的第一个元素中的任何一个是 “真”，则返回 “真”。

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

下面的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 <list2)
Output : FALSE FALSE TRUE

小于等于（<=）

如果第一个操作数的对应元素小于或等于第二个操作数的对应元素，返回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 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 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
检查指定列表中的值0.1。它存在，因此，打印出TRUE。

冒号运算符(:)

打印一个元素列表，从冒号前的元素开始到冒号后的元素。

Input : print (1:5)
Output : 1 2 3 4 5
打印一个从1到5的数字序列。

%*%运算符

该运算符用于将矩阵与它的转置相乘。矩阵的转置是通过将行与列以及列与行的互换而得到的。第一个矩阵的列数必须与第二个矩阵的行数相等。矩阵A与它的转置B相乘，产生一个正方形矩阵。

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 2×3
[1,] 1 3 5
[2,] 2 4 6
[,1] [,2] #transposed matrix of order 3×2
[1,] 1 2
[2,] 3 4
[3,] 5 6
[,1] [,2] #product matrix of order 2×2
[1,] 35 44
[2,] 44 56

下面的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