1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 手动构建向量
vec1 <- c(1,1,2,2,3,3,4,4)
vec2 <- c('1','2','3','4')

# 按顺序创建
vec3 <- 1:10 # 使用冒号快速创建序列 起始:终止
vec4 <- seq(0,100,by=10) # 起始、终止、步长

# 生成重复元素的向量
rep(0,100) # 生成100维的零向量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

vec <- 1:100

### 向量的元素提取
# 提取向量中第k个元素,或者某几个元素
vec[2] # 提取向量中第2个元素。在R中，编号是从1开始的（不是0！）。
vec[c(1,2,3,5,8)] # 提取第1，2，3，5，8位元素

# 随机提取向量k个元素
set.seed(123)
sample(vec,5)

### 向量操作
c(vec,vec) # 将两个向量进行拼接。R语言会自动打开每个向量为元素，而不是把向量整体作为元素
sort(vec) # 将vec元素进行排序
scale(vec) # 将vec中心标准化（中心化+标准化）
vec[1]=50 # 替换向量中的元素
vec[c(1,3,5)]=c(2,4,6) # 将向量中对应序号的元素替换为新的元素【有循环补齐效应】
which(vec==50) # 查找元素位置
match(vec,c(1,50,100)) # 匹配向量与指定元素
paste(vec,c(1),sep='_') # 将两个向量逐元素粘贴起来【有循环补齐效应】

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

### 作为集合的运算
## R语言中没有集合数据类型，但是可以将向量作为集合来计算
a = c(1,1,2,2,3,4,5)
b = c(2,2,2,2,3,5)
intersect(a,b) # 取交集，这里并不需要保证向量内元素唯一
union(a,b) # 取并集
setdiff(a,b) # 差集，a-b

### 描述性统计量
## 若有NA值可以加上na.rm=True参数
a = 1:100
length(a) # a中的元素个数
max(a) # a中元素的最大值
min(a) # a中元素的最小值
sum(a) # a中的所有元素之和
mean(a) # a中的元素均值
var(a) # a中所有元素的方差，自由度为n-1.想要计算整体方差应当乘以n-1/n
sd(a) # a中所有元素的标准差，自由度为n-1
median(a) # 中位数
quantiles <- quantile(a, probs = c(0.25, 0.75)) # 分位数，计算a的25%和75%分位数

### 向量的逻辑运算
## 同样，是对两个向量中对应元素依次进行计算或判断，若维数不相同则会循环补齐
a=c(TRUE,TRUE,FALSE,FALSE)
b=c(TRUE,FALSE,FALSE,TRUE)
a&b # 逻辑与
a|b # 逻辑或
!a # 逻辑非
a==b # 逐元素判断两个向量是否相等。

### 向量的数学运算
## 在进行两个向量运算时，R语言中会将较短的向量进行循环补齐直至和较长的向量维数一致。
a+1 # 每一个元素加上1，可以理解为R语言将一维向量循环补齐直至维数与a一致。
a-1 # 每个元素减去1
a*2 # 数乘，每个元素乘以2
a/2 # 每个元素除以2
a**2 # 每个元素平方
a+a # 对应元素相加，可以看成加减乘除的推广。本质是循环补齐特性。
a-a # 对应元素相减
a*a # 对应元素相乘
a/a # 对应元素相除
a**a # 对应元素计算幂

### 向量的简单线性代数运算
## 在不引入其它R包时，也可以进行一些简单的线性代数运算
a = 3:10
b = 4:11
t(a) # 向量的转置。R语言中向量默认为【列向量！】
dot_product = sum(a*b) # 点乘、内积
dot_product = a %*% b # 点乘的另一种写法，这种情况下生成的时1*1矩阵，必要时转为数值
dot_product <- as.numeric(dot_product)
l1_norm <- sum(abs(a)) # L1-范数
l2_norm <- sqrt(sum(a^2)) # L2-范数

1
2
3
4
5

### 手动创建矩阵
mtx = matrix(0,nrow=4,ncol=4) # 生成零矩阵
dig = diag(rep(1,4)) # 生成对角阵，需指定主对角线上的元素
mtx = matrix(data=rep(1,16),nrow=4,ncol=4,byrow=TRUE) #指定资料、行数、列数以及资料填充方向
mtx = rbind(1:3,4:6,7:9) # 按行拼接向量，也可以拼接两个矩阵。此外，cbind可以按列拼接

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

mtx = matrix(1:100,nrow=10,ncol=10,byrow=TRUE)

### 查看矩阵维数
dim(mtx)

### 矩阵行列重命名
rownames(mtx) = paste('X',1:10,sep='_')
colnames(mtx) = c(paste('A',1:5,sep='_'),paste('B',1:5,sep='_'))

### 矩阵元素提取
mtx[43] # 提取矩阵中第43号元素，是按列从上往下、从左往右数的【重要！】
mtx[4,3] # 提取第四行、第三列的元素
mtx[3:5,3:5] # 提取3-5行、3-5列的元素
mtx[,4] # 提取第四列
mtx[4,] # 提取第四行。不过不管是提取行还是列，最终输出的都是（列）向量
# 如果对行列进行了重命名，除了上述方法外，还可以直接用行名或列名进行提取
mtx[,'A_3'] # 提取名为A_3的列

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

mtx1 = matrix(sample(100,100),nrow=10,ncol=10)
mtx2 = matrix(sample(100,100),nrow=10,ncol=10)

### 矩阵的描述性统计量计算
rowSums(mtx1) # 求行和，返回每一行的总和
colSums(mtx1) # 求列和，返回每一列的总和
rowMeans(mtx1) # 求每一行的均值
colMeans(mtx1) # 求每一列的均值
mean(mtx1) # 求矩阵所有元素的均值
sd(as.vector(mtx1)) # 求矩阵整体标准差，即将矩阵拉成向量再求标准差
apply(mtx1, 1, sd) # 按行计算标准差，其中1表示行
apply(mtx1, 2, sd) # 按列计算标准差，其中2表示列
apply(mtx1, 1, var) # 按行计算方差
apply(mtx1, 2, var) # 按列计算方差
scale(mtx1) # 中心标准化，在R语言中是默认按【列】标准化的
# 此外，使用apply函数可以使用自定义操作
apply(mtx1,2,function(x)(x-min(x))/(max(x)-min(x))) # min-max标准化

### 矩阵对数、向量和矩阵都有对应的运算方式，并且同样有循环补齐的特性。矩阵中元素进行操作时的顺序是按列从上到下、从左到右依次计算
## 矩阵对数的计算
# 加减乘除和乘方
mtx1+2
mtx1-2
mtx1*2
mtx1/2
mtx1**2
## 矩阵对向量、矩阵的简单计算也是同理，遵循循环补齐原则

### 矩阵的线性代数运算
det(mtx1) # 行列式
t(mtx1) # 转置
solve(mtx1) # 求逆
det(mtx1)*solve(mtx1) # 伴随矩阵
qr(mtx1)$rank # 矩阵的秩
sum(diag(mtx1)) # 矩阵的迹
mtx1 * mtx2 # 对应元素相乘、Hadamard积
mtx1 %*% mtx2 # 内积、矩阵乘法
mtx1 %o% mtx2 # 外积、克罗内克积
eigen(mtx1) # 特征值分解
qr(mtx1) # 矩阵的qr分解
svd(mtx1) # 矩阵的svd分解
prcomp(mtx1) # 主成分分析

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

library(Matrix)

### 稀疏矩阵的构建与转化
mtx=diag(rep(1,10))
Matrix(data=mtx,sparse=TRUE) # 转为稀疏矩阵
mtx <- as(mtx, "sparseMatrix") # 也可以转化为稀疏矩阵
mtx <- as(mtx, "matrix") # 稀疏矩阵转化为密集矩阵

### 稀疏矩阵的计算
## 稀疏矩阵计算与普通矩阵计算是兼容的
## 但是在某些操作时需谨慎，可能会将稀疏矩阵转化为稠密矩阵