R语言(2)：向量【未完成版】

2.1 标量、向量、数组、矩阵

R语言中变量类型称为模式（mode），同一向量中的所有元素必须是相同的模式，可以是整型、数值型、字符型、逻辑型（布尔类型）、复数型。查看类型用typeof()

2.1.1 添加 删除向量

相当于重新赋值！

x <- c(88,5,12,13)
x <- c(x[1:3],168,x[4]) #结果： 88，5，12，168，13
x <- c(x[3],111,x[4])  #结果： 12，11，13

也可以通过索引删除：

> z <- c(1,2,3,4)
> z[c(-1,-3)]
[1] 2 4
> z[-length(z)]
[1] 1 2 3

2.1.2 获取向量长度

用length()函数

运用length函数，找到向量中第一个1的索引

# 第一个文件 first1 文件
first1 <- function(x){
  for (i in 1:length(x)){
    if (x[i]==1) break
  }
  return(i)
}

#调用函数
setwd("D:/Rfiles")   
x <- c(2,1,3,4,2)
source("first1.R",encoding="utf-8")  
m = first1(x)
m

2.2 创建空向量

y <- vector(length = 2)
y[1] <- 5
y[2] <- 6 #创建好之后才可以进行赋值

2.3 循环补齐

当对两个向量使用运算符时，如果要求这两个向量具有相同的长度，R会自动循环补齐（recycle）

注意是按照列的形式相加的，因为R语言是按照列的方式进行存储的！

2.4 常用的向量运算

2.4.1 向量的逻辑运算

加法的两种形式：

> m <- 2+3
> m
[1] 5
> n <- "+"(2,3)
> n
[1] 5

数值运算符作用在向量是 对应的元素做运算

* 相乘 /相除 %%取余

2.4.2 向量索引

> y <- c(1,2,3,4,5)
> y[c(1,3)] #!!!!!!!!
[1] 1 3
> y[2:3]
[1] 2 3
> v <- 3:4
> y[v]
[1] 3 4
> y[c(1,1,3)]  #元素重复是允许的！
[1] 1 1 3

2.4.3 用：创建向量

要写成 1：3 注意在for循环中要写成 for i in

2.4.4 使用seq()创建等差间隔的向量

用于生成等差数列

> seq(from = 12,to =30, 3) # 步长是3，生成
[1] 12 15 18 21 24 27 30
> seq(from = 2.1, to=4, length = 10)  #在2.1 和 4之间形成等间隔的10个向量
 [1] 2.100000 2.311111 2.522222 2.733333 2.944444 3.155556
 [7] 3.366667 3.577778 3.788889 4.000000

2.4.5 使用rep()生成重复向量

> x <- rep(8,4)
> x
[1] 8 8 8 8
> rep(5:8,2)
[1] 5 6 7 8 5 6 7 8
> rep(c(1,4,5),2)
[1] 1 4 5 1 4 5

2.5 使用all()和any() 快速判断大小

> x <- 1:10
> any(x >8)
[1] TRUE
> all(x>8)
[1] FALSE
> any(11)
[1] TRUE
> any(x>11)
[1] FALSE

2.5.1 扩展案例：寻找连续出现1的游程

findruns <- function(x,k){
    n <- length(x)
    print(n)
    runs <- NULL #必须大写！！！ 
    for (i in 1:(n-k+1)){ #注意 1：3这种东西不要在外面加括号，加的话要写成c(1:3)
      print(i)
      if (all(x[i:(i+k-1)]==1)) runs <- c(runs,i) #
      }
    return(runs)
}
y <- c(1,0,0,1,1,1,0,1,1)
m = findruns(y,3)

2.6 向量化运算符

假设我们希望对向量x中的每一个元素使用函数f()。在很多情况下，我们可以简单的调用f()就能完成。这可以简化我们的代码，提高运行效率。

向量化运算符的含义就是：将运算符也拓展成向量的形式，这样就可以实现运算符作用在向量的每一个元素上了。

2.6.1 向量输入，向量输出

u <- c(5,2,8)
v <- c(1,3,9)
u >v
#结果
#[1]  TRUE FALSE FALSE

u <- c(5,2,8)
w <- function(x) return(x+1)
w(u)
#结果：
#[1] 6 3 9

> #超越函数（平方根、对数、三角函数等）,R中许多内置函数。例：
> sqrt(1:9)
[1] 1.000000 1.414214 1.732051
[4] 2.000000 2.236068 2.449490
[7] 2.645751 2.828427 3.000000
> y <- c(1.2,3.9,0.4)
> z <- round(y)  # 求与每个元素距离最近的整数值
> z
[1] 1 4 0
> y +4
[1] 5.2 7.9 4.4
> '+'(y,4)
[1] 5.2 7.9 4.4

最后一个的意思是：将y和4相加

2.6.2 向量输入，矩阵输出

sapply()函数简化，sapply(x,f)指对x的每一个元素使用函数f(),并将结果转化为矩阵。

#函数本身的返回值就是向量：
> z12 <- function(z) return(c(z,z^2))
> x <- 1:8
> z12(x)
 [1]  1  2  3  4  5  6  7  8  1  4
[11]  9 16 25 36 49 64
> matrix(z12(x),ncol =2)
     [,1] [,2]
[1,]    1    1
[2,]    2    4
[3,]    3    9
[4,]    4   16
[5,]    5   25
[6,]    6   36
[7,]    7   49
[8,]    8   64
> #也可以用sapply()函数简化，sapply(x,f)指对x的每一个元素使用函数f(),并将结果转化为矩阵。例:
> z12 <- function(z) return(c(z,z^2))
> sapply(1:8,z12)
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    2    3    4    5    6
[2,]    1    4    9   16   25   36
     [,7] [,8]
[1,]    7    8
[2,]   49   64

2.7 NA与NULL值

NA：缺失值，存在但未知    NULL：不存在的值

2.7.1 NA的使用

> #跳过缺失值NA：使用na.rm设置
> x <- c(88,NA,12,168,13)
> mean(x)
[1] NA
> mean(x,na.rm = T)
[1] 70.25
> x <- c(88,NULL,12,168,13)
> mean(x)
[1] 70.25
> #NA值的模式可有多种：
> x <- c(5,NA,12)
> mode(x[1])
[1] "numeric"
> mode(x[2])
[1] "numeric"
> y <-c('abc','def',NA)
> mode(y[3])
[1] "character"

2.7.2 NULL的使用

>#使用NULL创建空变量：
> z <- NULL
> for (i in 1 :10) if(i %% 2 ==0) z <- c(z,i)
> #NA与NULL的区别：
> z <- NA
> for (i in 1 :10) if(i %% 2 ==0) z <- c(z,i)
> u <- NULL
> length(u)
[1] 0
> v <- NA
> length(v)
[1] 1
> #注意：NULL是R中的特殊现象，它没有模式

2.8 筛选

2.8.1 生成筛选索引

通过筛选提取向量中满足一定条件的元素。

> z <- c(5,2,-3,8)
> w <- z[ z*z > 8 ]  #提取z中平方大于8的数
> w
[1]  5 -3  8

> z <- c(5,2,-3,8)
> j <- z*z > 8
> j
[1]  TRUE FALSE  TRUE  TRUE
> y <- c(1,2,30,5)
> y[j]
[1]  1 30  5

2.8.2 使用subset()函数筛选

subset()函数处理NA值与普通方法不同，subset()会自动剔除NA值。

> x <- c(6, 1:3, NA, 12)
> x
[1]  6  1  2  3 NA 12
> x[x>5]
[1]  6 NA 12
> subset(x, x>5)
[1]  6 12

2.8.3 选择函数which()

which()返回满足相应条件元素所在的位置

> z <- c(5,2,-3,8)
> which(z*z >8)
[1] 1 3 4

找到一个向量中满足一定条件的元素首次出现的位置。

first1 <- function(x){ #找到第一个1
  for (i in 1:length(x)) {
    if (x[i] == 1) break
  }
  return(i)
}
first1(c(2,1,3))
#结果：2

或者：

first1a <- function(x) return(which(x == 1)[1])

first1a(c(2,1,3))

2.9 向量化的ifelse()函数

ifelse()是向量化版本的if-then-else结构：ifelse(b,u,v)，其中b为一个布尔值向量，u和v为向量。 函数返回值为向量，如b[i]为真，则第i个返回元素为u[i]，反之为v[i]。

> x <- 1:10
> y <- ifelse( x%%2 == 0, 5, 12) #偶数返回5，奇数返回12
> y
 [1] 12  5 12  5 12  5 12  5 12  5

> x <- c(5,2,9,12)
> ifelse(x>6,2*x,3*x)
[1] 15  6 18 24

2.9.1 扩展案例：度量相关性

#对于两组向量x和y，通过比较同时上升或下降次数占总观测数的比例来衡量两者的相关性。
> findud <- function(v){ #用1,0序列表示一个向量升降次序，1为升，0为降
+   vud <- v[-1] - v[-length(v)]
+   return(ifelse(vud>0,1,0))
+ }
> udcorr <- function(x,y) { 
+   ud <- lapply(list(x,y),findud)  #将x,y放入同一个列表用lapply调用findud
+   return(mean(ud[[1]] ==ud[[2]]))
+ }
> x <- c(5,12,13,3,6,0,1,15,16,8,88)
> y <- c(4,2,3,23,6,10,11,12,6,3,2)
> udcorr(x,y)
[1] 0.4

2.10 测试向量相等

测试两个向量是否相等，不可直接用==符号。

如： x <- 1:3 y <- c(1,3,4) x == y

应用all()函数： all(x == y)

或者： identical(x,y) 需注意identical是判断两者是否完全一样，

如：

> x <- 1:2
> y <- c(1,2)
> all(x==y)
[1] TRUE
> identical(x,y)
[1] FALSE
> typeof(x)
[1] "integer"
> typeof(y)
[1] "double"

2.11 向量元素的名称

> #可以用names()函数给向量中的元素命名或查询其名称。例：
> x <- c(1,2,4)
> names(x)
NULL
> names(x) <- c('a','b','ab')
> names(x)
[1] "a"  "b"  "ab"
> #移除向量名：
> names(x) <- NULL
> #用名称引用向量元素：
> x <- c(1,2,4)
> names(x) <- c('a','b','ab')
> x['b']
b 
2 

2.12 关于c()的更多内容、

若c()中参数类型不同，则统一降级为同种类型：

> c(5,2,'abc') #全部降为字符型
[1] "5"   "2"   "abc"
> c(5,2,list(a=1,b = 4)) #全部降为列表型
[[1]]
[1] 5

[[2]]
[1] 2

$a
[1] 1

$b
[1] 4