北京大学R语言教程(李东风)第16章： 程序控制结构

if(is.na(lambda)) lambda <- 0.5

if(x>1) {
  y <- 2.5
} else {
  y <- -y
}

x <- c(0.05, 0.6, 0.3, 0.9)
for(i in seq(along=x)){
  if(x[i] <= 0.2){
    cat("Small\n")
  } else if(x[i] <= 0.8){
    cat("Medium\n")
  } else {
    cat("Large\n")
  }
}

用逻辑下标代替分支结构

R是向量化语言，尽可能少用标量运算。
比如，x为一个向量，要定义y与x等长，
且y的每一个元素当且仅当x的对应元素为正数时等于1， 否则等于零。

这样是错误的：

if(x>0) y <- 1 else y <- 0

正解为:

y <- numeric(length(x))
y[x>0] <- 1
y

ifelse函数

函数ifelse()可以根据一个逻辑向量中的多个条件，
分别选择不同结果。如

x <- c(-2, 0, 1)
y <- ifelse(x >=0, 1, 0); print(y)

## [1] 0 1 1

函数ifelse(test, yes, no)中的test是逻辑向量，
yes和no是向量，
test、yes和no的配合符合向量化原则，
如果有长度为1的或者长度较短但其倍数等于最长一个的长度的，
短的一个自动从头循环使用。如：

ifelse((1:6) >= 3, 1:2, c(-1,-2))

## [1] -1 -2  1  2  1  2

当然，最常见的还是yes、no为标量的情形。

不同于if语句，
ifelse的test中运行有缺失值，
对应结果也是缺失值。

dplyr包的if_else函数与基本R的ifelse功能基本相同，
但允许指定条件为缺失值时的不同处理方法。

switch函数

函数switch()可以建立多分枝结构,
可以根据一个整数表达式或者一个字符串表达式的值选择返还相对应的值。

例如，某校将百分制转换到等级制的规则如下：

• 98-100: A+
• 95-97: A
• 90-94: A-
• 85-89: B+
• 80-84: B
• 77-79: B-
• 73-76: C+
• 70-72: C
• 67-69: C-
• 63-66: D+
• 60-62: D
• 0-59: F

从百分制转换为等级制可以用if-else if-else完成。
从等级制转换回百分制，用区间平均值，可以写成switch()的写法：

gr_v <- c("A+", "A", "A-", "B+", "B", "B-", 
  "C+", "C", "C-", "D+", "F", "EX")
for(gr in gr_v){
  switch(gr,
    "A+" = 99,
    "A" = 96,
    "A-" = 92,
    "B+" = 87,
    "B" = 82,
    "B-" = 78,
    "C+" = 75,
    "C" = 71,
    "C-" = 68,
    "D+" = 65,
    "F" = 50,
    NA)
}

switch()中的最后一个选择通常用于所有前面选择都不匹配时的一个例外情况处理，
这里的例子对这种情况返回缺失值。
上例中用了for循环，见下一节的说明。

switch()中允许对多个值采取同一行动或者返回同一结果，
如：

for(ch in c("a", "i", "c")){
  cat(ch, ":", switch(ch,
    "a"=, "e"=, "i"=, "o"=, "u" = "Vower",
    "Consonant"), "\n")
}

## a : Vower 
## i : Vower 
## c : Consonant

在上例中，a, e, i, o, u返回相同的值"Vower"，
而其它值则返回"Consonant"。

如果要建立1:n到x1∼xn的映射，
可以用整数下标的方法；
如果要建立s1∼sn(字符串向量）到x1∼xn的映射，
可以用有名向量的方法。
switch()则可以处理有例外项的问题。
更一般的分支，
尤其是不同分支执行不同命令的情况，
应该使用if-else if-else结构。

dplyr包的case_when函数可以switch()的向量化推广，
看成是ifelse的多分支推广，
或看成if-else if-else语句的向量化。 输入条件是向量化的， 根据输入条件返回条件对应的结果。 所有条件都不满足的元素的输出结果为NA`。

如：

v <- c("A+", "A", "A-", "B+", "B", "B-", 
  "C+", "C", "C-", "D+", "F", "EX")
dplyr::case_when(
    v == "A+" ~ 99,
    v == "A" ~ 96,
    v == "A-" ~ 92,
    v == "B+" ~ 87,
    v == "B" ~ 82,
    v == "B-" ~ 78,
    v == "C+" ~ 75,
    v == "C" ~ 71,
    v == "C-" ~ 68,
    v == "D+" ~ 65,
    v == "F" ~ 50)

##  [1] 99 96 92 87 82 78 75 71 68 65 50 NA

x <- c("a", "i", "c")
dplyr::case_when(
  x %in% c("a", "e", "i", "o", "u") 
  ~ "Vowel",
  TRUE
  ~ "Consonant"
)

## [1] "Vowel"     "Vowel"     "Consonant"

计数循环

为了对向量每个元素、矩阵每行、矩阵每列循环处理，语法为

for(循环变量 in 序列) 语句

其中的语句一般是复合语句。
如：

set.seed(101); x <- rnorm(5)
y <- numeric(length(x))
for(i in 1:5){
  if(x[i]>=0) y[i] <- 1 else y[i] <- 0
}
print(y)

## [1] 0 1 0 1 1

其中rnorm(5)会生成5个标准正态分布随机数。
numeric(n)生成有n个0的数值型向量（基础类型为double）。

如果需要对某个向量x按照下标循环，
获得所有下标序列的标准写法是seq_along(x),
而不用1:n的写法，
因为在特殊情况下n可能等于零，这会导致错误下标，
而seq_along(x)在x长度为零时返回零长度的下标。

例如，设序列xn满足x0=0, xn=2xn−1+1,
求Sn=∑ni=1xn:

x <- 0.0; s <- 0; n <- 5
for(i in 1:n){
  x <- 2*x + 1
  s <- s + x
}
print(s)

## [1] 57

在R中应尽量避免for循环：
其速度比向量化版本慢一个数量级以上，
而且写出的程序不够典雅。
比如，前面那个示性函数例子实际上可以简单地写成

set.seed(101); x <- rnorm(5)
y <- ifelse(x >= 0, 1, 0)
print(y)

## [1] 0 1 0 1 1

许多计数循环都可以用lapply、vapply、sapply、apply、map、Map等函数替代，
详见18.3。

用break语句退出所在的循环。
用next语句进入所在循环的下一轮。

使用for循环的注意事项：

• 如果对向量每个元素遍历并保存结果，
  应在循环之前先将结果变量产生等长的存储，
  在循环内为已经分配好存储空间的输出向量的元素赋值。
  为了产生长度为n的数值型向量，用numeric(n)；
  为了产生长度为n的列表，用vector("list", n)。
• 对一个向量元素遍历时如果用下标访问，
  需要用seq_along(x)的做法而不是1:length(x)的做法。
• 如果直接对向量元素遍历，
  这有可能会丢失向量的属性（如日期型），
  用下标访问则不存在此问题。

如：

x <- as.POSIXct(c("1981-05-31", "2020-02-22"))
for(xi in x){print(xi)}

## [1] 360086400
## [1] 1582300800

for(i in seq_along(x)){print(x[i])}

## [1] "1981-05-31 CST"
## [1] "2020-02-22 CST"

while循环和repeat循环

用

while(循环继续条件) 语句

进行当型循环。
其中的语句一般是复合语句。
仅当条件成立时才继续循环，
而且如果第一次条件就已经不成立就一次也不执行循环内的语句。

用

repeat 语句

进行无条件循环（一般在循环体内用if与break退出）。
其中的语句一般是复合语句。
如下的写法可以制作一个直到型循环：

repeat{
  ...
  if(循环退出条件) break
}

直到型循环至少执行一次，
每次先执行...代表的循环体语句，
然后判断是否满足循环退出条件，
满足条件就退出循环。

例如，
常量e的值可以用泰勒展开式表示为

e=1+∑k=1∞1k!

R函数exp(1)可以计算e的为了计算e的值，
下面用泰勒展开逼近计算e的值：

e0 <- exp(1.0)
s <- 1.0
x <- 1
k <- 0
repeat{
  k <- k+1
  x <- x/k
  s <- s + x
  
  if(x < .Machine$double.eps) break
}
err <- s - e0
cat("k=", k, " s=", s, " e=", e0, " 误差=", err, "\n")

## k= 18  s= 2.718282  e= 2.718282  误差= 4.440892e-16

其中.Machine$double.eps称为机器ε，
是最小的加1之后可以使得结果大于1的正双精度数，
小于此数的正双精度数加1结果还等于1。
用泰勒展开公式计算的结果与exp(1)得到的结果误差在10−16左右。

asin(0.5) |> round(digits=4)

6 |> round(pi,  digits = _)