ベクトル - R入門【6/20更新】

目次

基本操作

ベクトルとは

Rでは数値や文字などの値を扱う際、同じ種類の値はひとまとめにして扱う。このひとまとめにした値の入れ物をベクトルという。ベクトルに含める値は1個もあれば複数個もあり、0個の場合もある。ベクトルを作る方法はいろいろあるが、c関数を使うと簡単に作成することができる。

> n <- c(1, 2, 3, 5)
> print(n)
[1] 1 2 3 5
> s <- c("カナメ", "フレイア", "美雲", "マキナ", "レイナ")
> print(s)
[1] "カナメ"   "フレイア" "美雲"     "マキナ"   "レイナ"  
> s <- "ワルキューレ"
> print(s)
[1] "ワルキューレ"
> d <- double(0)
> print(d)
numeric(0)

1つ目の例は、4つの数値をひとまとめにしたベクトルを作成している。2つ目の例は、5つの文字列をひとまとめにしたベクトルを作成している。3つ目の例のとおり、値を1つしか持たないベクトルも作成することができる。最後の例では、値を1つも持たないベクトルを作成している。

ベクトルを作成する

c関数を使う。引数に各要素の値を,（コンマ）で区切って指定する。要素ではなく他のベクトルを指定することもでき、その場合はそのベクトルの要素すべてを指定したことになる。ベクトルとは同じ型の値をひとまとめにしたものであり、最後の例のとおり、型が異なる要素を指定すると、適当に強制変換されて作成されてしまうことに注意。

> n <- c(101, 102, 103)
> print(n)
[1] 101 102 103
> n <- c(n, 104)
> print(n)
[1] 101 102 103 104
> s <- c("イレイナ", "帰忘の流離人", "セナディア")
> print(s)
[1] "イレイナ"     "帰忘の流離人" "セナディア"  
> s <- c("ルアン・メェイ", s)
> print(s)
[1] "ルアン・メェイ" "イレイナ"       "帰忘の流離人"   "セナディア"   
> print(c(1, 2, "3"))
[1] "1" "2" "3"

ベクトルに値を代入する

代入演算子<-を使う。

> n <- 58
> s <- "ライスシャワー役の石見舞菜香さんかわいい"
> n
[1] 58
> s
[1] "ライスシャワー役の石見舞菜香さんかわいい"

数値型ベクトルの宣言と初期化

数値の計算をするために変数（ベクトル）を使うには、その数値を格納する領域とそれに名前を与える必要がある。これを宣言という。

整数はinteger関数、実数はdouble関数を使って宣言する。引数に何も与えないと長さが0のベクトルを作成する。ベクトルの長さを得るにはlength関数を使う。

> n
 エラー:  オブジェクト 'n' がありません 
> n <- integer()
> n
integer(0)
> length(n)
[1] 0
> n <- integer(3)
> n
[1] 0 0 0
> length(n)
[1] 3
> n[2] <- 4
> n
[1] 0 4 0
> d <- double(4)
> d
[1] 0 0 0 0
> d[4] <- 1.23
> d
[1] 0.00 0.00 0.00 1.23

Rでは数値型は基本的に実数のため、integer関数で作成したベクトルも、実数を代入することができる。

> n[3] <- 4.5
> n
[1] 0.0 4.0 4.5

ベクトルに要素を追加する

c関数を使う。Rにおける値の処理は基本的にベクトル単位のため、ベクトルを作成するc関数にベクトルを与えれば、複数のベクトルから1つのベクトルを作ることができる。

> s1 <- c("カナメ", "フレイア")
> s2 <- c("マキナ", "レイナ")
> s <- c(s1, "美雲", s2)
> print(s)
[1] "カナメ"   "フレイア" "美雲"     "マキナ"   "レイナ"

ベクトルの要素の先頭に要素を追加する

c関数を使う。

> s <- c("石見舞菜香", "和多田美咲", "のぐちゆり")
> print(s)
[1] "石見舞菜香" "和多田美咲" "のぐちゆり"
> s <- c("鈴木みのり", s)
> print(s)
[1] "鈴木みのり" "石見舞菜香" "和多田美咲" "のぐちゆり"

append関数も使える。afterオプションには、挿入したい場所の直前のインデックスを指定する。この例では先頭（=1）に挿入したいのでその直前である0を指定する。

> s <- append(s, "大橋彩香", after = 0)
> print(s)
[1] "大橋彩香"   "鈴木みのり" "石見舞菜香" "和多田美咲" "のぐちゆり"

ベクトルの要素の最後に要素を追加する

c関数を使う。

> s <- c("鈴木みのり", "石見舞菜香", "和多田美咲")
> print(s)
[1] "鈴木みのり" "石見舞菜香" "和多田美咲"
> s <- c(s, "のぐちゆり")
> print(s)
[1] "鈴木みのり" "石見舞菜香" "和多田美咲" "のぐちゆり"

append関数も使える。afterオプションには、挿入したい場所の直前のインデックスを指定できるが、afterオプションのデフォルトの値はlength(s)であるので、最後の要素の次に追加される。

> s <- append(s, "野口瑠璃子")
> print(s)
[1] "鈴木みのり" "石見舞菜香" "和多田美咲" "のぐちゆり" "野口瑠璃子"

ベクトルの要素の任意の場所に要素を追加する

append関数を使う。afterオプションには、挿入したい場所の直前のインデックスを指定する。

> s <- c("石見舞菜香", "のぐちゆり")
> s <- append(s, "和多田美咲", after = 1)
> print(s)
[1] "石見舞菜香" "和多田美咲" "のぐちゆり"

afterオプションに0を指定すると先頭に要素を挿入する。afterオプションのデフォルトの値はlength(s)であるので、何も指定しなければ、自動的に最後の要素の次に追加される。

> s <- append(s, "大橋彩香", after = 0)
> print(s)
[1] "大橋彩香"   "石見舞菜香" "和多田美咲" "のぐちゆり"
> s <- append(s, "野口瑠璃子")
> print(s)
[1] "大橋彩香"   "石見舞菜香" "和多田美咲" "のぐちゆり" "野口瑠璃子"

ベクトルの長さ（要素数）を得る

length関数を使う。

> d <- c(1.0, 2.0, 3.0)
> length(d)
[1] 3
> n <- 0:255
> length(n)
[1] 256
> d <- double()
> length(d)
[1] 0

最後の例のとおり、何も代入されていない空のベクトルは長さが0となる。

ベクトルから指定の要素の値を得る

[ ]演算子を使ってインデックスを指定する。取得したい要素の番号をベクトルで与える。ベクトルのインデックスは1から始まる自然数であることに注意。

> n <- c(10, 20, 30, 40, 50)
> n
[1] 10 20 30 40 50
> n[c(1, 2, 4)]  # 1,2,4番目の要素を抜き出し
[1] 10 20 40
> n[-c(1, 2, 4)]  # 1,2,4番目以外の要素を抜き出し
[1] 30 50

上の例のとおり、ベクトルをマイナスで指定すると、それ以外、という指定になる。

ベクトルから指定の要素を取り除く

要素を取り出す場合、インデックスに正数の数値を与えればよいが、取り除く場合は、インデックスに負数の数値を与えればよい。

> s <- c("A", "B", "C", "D", "E")
> s[c(1, 2, 4)]
[1] "A" "B" "D"
> s[-c(1, 2, 4)]
[1] "C" "E"
> s[c(-1, -2, -4)]
[1] "C" "E"
> s[-c(100)]
[1] "A" "B" "C" "D" "E"

最後の例のとおり、存在しないインデックスの負数を与えると無視される。

ベクトルを連結する

c関数を使う。

> n1 <- 1:3
> n2 <- 4:7
> print(n1)
[1] 1 2 3
> print(n2)
[1] 4 5 6 7
> print(c(n1, n2))
[1] 1 2 3 4 5 6 7

ベクトルの特殊な値（NULL, NA, NaN, Inf）

NULL

ヌル。要素が空であること。この「空」とは、0や""が入っているわけではなく、それすら格納されていない、まっさらな状態ということ。NULLか否かの判定には、is.null関数を使う。

> n <- c(NULL)
> print(n)
NULL
> length(n)
[1] 0
> n <- c(1:2, NULL, 3:5)
> print(n)
[1] 1 2 3 4 5
> length(n)
[1] 5
> print(is.null(NULL))
[1] TRUE
> print(is.null(NA))
[1] FALSE
> print(is.null(NaN))
[1] FALSE

よくある使い方として、for文などで繰り返し値を追加するベクトルの初期化に使われる。

> n <- as.integer(NULL)
> print(n)
integer(0)
> for (i in 1:4) n <- append(n, 2 ^ i)
> print(n)
[1]  2  4  8 16

NA

Not Available。欠損値のこと。ベクトルの特殊な値の一つ。NAはどのような演算をしても、演算結果はNAになる。NAか否かの判定にはis.na関数を使う。

> n <- c(1, 2, NA, 4)
> print(n)
[1]  1  2 NA  4
> print(n + 10)
[1] 11 12 NA 14
> print(n / 2)
[1] 0.5 1.0  NA 2.0
> print(n == 1)
[1]  TRUE FALSE    NA FALSE
> print(is.na(n))
[1] FALSE FALSE  TRUE FALSE

NaN

ナン。Not A Number。非数のこと。ベクトルの特殊な値の一つ。ゼロ除算などで正常な演算結果が得られなかった場合にNaNになる。NaNか否かの判定にはis.nan関数を使う。

> print(0 / 0)
[1] NaN
> print(Inf / Inf)
[1] NaN
> is.nan(NA)
[1] FALSE
> is.nan(Inf / Inf)
[1] TRUE

Inf

数値計算における無限大（∞）のこと。ベクトルの特殊な値の一つ。演算結果が無限大になる演算結果がInfになる。数学同様、負数の無限大もある。Infか否かの判定には、is.infinite関数を使う。

> print(1 / 0)
[1] Inf
> print(-1 / 0)
[1] -Inf
> 1 / 1.e-308
[1] 1e+308
> 1 / 1.e-309
[1] Inf
> n <- c(1, 2, Inf, 4)
> print(n)
[1]   1   2 Inf   4
> print(is.infinite(n))
[1] FALSE FALSE  TRUE FALSE

要素の操作

ベクトルの各要素にまとめて演算を行う

Rでは、プログラミング言語でいうところの変数はベクトルといい、値や情報を一つ以上まとめて格納できる配列である。そのため、特定の処理以外は、演算は原則として各要素に一つずつまとめて行うことになる。

> d <- 8
> print(2 ^ d)
[1] 256
> d <- c(0, 1, 2, 3, 4, 5, 6, 7, 8)
> print(2 ^ d)
[1]   1   2   4   8  16  32  64 128 256
> s <- c("石見舞菜香", "鈴木みのり", "野口瑠璃子", "和多田美咲")
> print(paste(s , "さん", sep = ""))
[1] "石見舞菜香さん" "鈴木みのりさん" "野口瑠璃子さん" "和多田美咲さん"

演算の戻り値は、元のベクトルと同じ要素数を持つベクトルになる。そのため、それをそのまま次の演算に使用することができる。

> s <- c("瀬戸麻沙美", "優木かな")
> print(paste(s , "さん", sep = ""))
[1] "瀬戸麻沙美さん" "優木かなさん"  
> print(paste(s , "さん", sep = "") |> paste("、すごくかわいい", sep = ""))
[1] "瀬戸麻沙美さん、すごくかわいい" "優木かなさん、すごくかわいい"

すべての演算をまとめて行うことができるわけではないことに注意。例えば、if文の条件式は一つの要素しか扱うことができず、要素の数が一つではないベクトルを指定するとエラーが発生する。

> if (s == "石見舞菜香") print("ライスシャワー")
if (s == "石見舞菜香") print("ライスシャワー") でエラー: 
  the condition has length > 1
> if (s[1] == "石見舞菜香") print("ライスシャワー")
[1] "ライスシャワー

ベクトルから指定の条件に一致する要素を抜き出す

which関数を使う。戻り値はインデックスであることに注意。指定の条件に一致する要素がない場合は、長さが0のベクトルが返される。最後の例のとおり、|記号（||記号ではない！）を使うと複数の条件を指定することもできる。

> n <- 2 ^ (0:8)
> print(n)
[1]   1   2   4   8  16  32  64 128 256
> which(n > 100)
[1] 8 9
> which(n > 1000)
integer(0)
> length(which(n > 100))
[1] 2
> length(which(n > 1000))
[1] 0
> seiyu <- c("安野希世乃", "鈴木みのり", "本渡楓")
> which(seiyu == "鈴木みのり")
[1] 2
> which(seiyu == "鈴木みのり" | seiyu == "本渡楓")
[1] 2 3

ベクトルから最大（最小）の値を抜き出す

max関数、min関数は引数にベクトルを指定すると、それぞれ最大、最小の値を返す。

> d <- c(3.0, 1.0, 2.0)
> max(d)
[1] 3
> min(d)
[1] 1

ベクトルから最大（最小）の値の要素のインデックスを得る

which.max（which.min）関数を使う。以下、例。

> n <- c(70, 60, 90, 80)
> max(n)
[1] 90
> min(n)
[1] 60
> which.max(n)
[1] 3
> which.min(n)
[1] 2

which.maxとwhich.min関数は、which関数を以下のように使った場合と同じ。

> which(n == max(n))
[1] 3
> which(n == min(n))
[1] 2

最大、最小の値が複数ある場合は、最小のインデックスが返される。

> n <- c(70, 60, 60, 80, 80)
> which.max(n)
[1] 4
> which.min(n)
[1] 2

ベクトルから正規表現のパターンにマッチしたものをベクトルから取り除く

grep関数のINVERTオプションを使う。

> s <- c("A", "B", "C", "D")
> s
[1] "A" "B" "C" "D"
> grep("B", s)
[1] 2
> grep("B", s, invert = TRUE)
[1] 1 3 4
> grep("B", s, invert = TRUE, value = TRUE)
[1] "A" "C" "D"

ベクトルから非数（NA）を取り除く

非数（NA）はその名のとおり数としては扱えない値であり、算術関数はNAが1つでも含まれていると、正常に動作しない。

> d <- c(20, 30, NA, 5)
> mean(d)
[1] NA
> max(d)
[1] NA

これを正常に動作させるには、is.na関数を使用してNAの要素を取り除けばよい。is.na関数は引数に与えたベクトルの要素がNAであればTRUE、そうでなければFALSEを返す。これを利用して、処理するベクトルの要素番号を指定して当該関数に与えればよい。

> is.na(d)
[1] FALSE FALSE  TRUE FALSE
> d[!is.na(d)]
[1] 20 30  5
> mean(d[!is.na(d)])
[1] 18.33333
> max(d[!is.na(d)])
[1] 30

ベクトルの要素をソートする

並び替えた結果を値で得る場合はsort関数を、その並び替えられたインデックスが欲しい場合はorder関数を使う。デフォルトでは昇順で返す。降順で返す場合はdecreasingにTRUEを与える。

> d <- c(4.0, 0.0, -3.2, 5.1)
> sort(d)
[1] -3.2  0.0  4.0  5.1
> order(d)
[1] 3 2 1 4
> sort(d, decreasing = TRUE)
[1]  5.1  4.0  0.0 -3.2
> order(d, decreasing = TRUE)
[1] 4 1 2 3

文字列にも使える。

> s <- c("A", "AB", "ABC", "ab", "あい", "阿")
> sort(s)
[1] "A"    "ab"   "AB"   "ABC"  "あい" "阿"  
> order(s)
[1] 1 4 2 3 5 6
> sort(s, decreasing = TRUE)
[1] "阿"   "あい" "ABC"  "AB"   "ab"   "A"   
> order(s, decreasing = TRUE)
[1] 6 5 3 2 4 1

ベクトルの要素を逆順に並び替える

rev関数を使う。

> n <- c(1:3, 5:4)
> s <- c("A", "B", "D", "C")
> print(n)
[1] 1 2 3 5 4
> print(s)
[1] "A" "B" "D" "C"
> print(rev(n))
[1] 4 5 3 2 1
> print(rev(s))
[1] "C" "D" "B" "A"

ベクトルで条件分岐を行う

if文ではなくifelse関数を使う。以下、例。

> n <- 1:5
> n
[1] 1 2 3 4 5
> ifelse(n >= 3, "Yes", "No")
[1] "No"  "No"  "Yes" "Yes" "Yes"
> if (n >= 3) "Yes" else "No"
[1] "No"
 警告メッセージ: 
 if (n >= 3) "Yes" else "No" で: 
   条件が長さが 2 以上なので、最初の 1 つだけが使われます

最後の例のとおり、通常のif分はベクトルの最初の要素しか扱われない。

単純集計を行う

table関数を使う。excludeオプションを使うことで、特定の値を集計から除くことが出来る。

> name <- c("A", "A", "A", "A", "B", "B", "C")
> print(name)
[1] "A" "A" "A" "A" "B" "B" "C"
> table(name)
name
A B C 
4 2 1 
> table(name, exclude = "B")
name
A C 
4 1

戻り値はテーブル形式のため、集計結果の中身を個別に扱うには、データフレームに変換する。

> dtf <- as.data.frame(table(name))
> print(dtf)
  name Freq
1    A    4
2    B    2
3    C    1
> dtf[3, 2]
[1] 1
> sum(dtf[, 2])
[1] 7

ベクトルの要素同士を比較する

ベクトル同士を比較演算して比較すると、要素数が同じか、一方の要素数が一方の整数倍の場合のみ、要素同士で比較することが可能。

> i <- c(1, 2, 3, 4)
> j <- c(1, 2, 3)
> k <- c(1, 2, 4)
> l <- c(1, 2)
> m <- 4
> j == k
[1]  TRUE  TRUE FALSE
> i == l
[1]  TRUE  TRUE FALSE FALSE
> i == m
[1] FALSE FALSE FALSE  TRUE
> i == j
[1]  TRUE  TRUE  TRUE FALSE
 警告メッセージ: 
 i == j で: 
   長いオブジェクトの長さが短いオブジェクトの長さの倍数になっていません

上記の等号の比較演算子による比較は、互いの要素すべてが同じ場合、戻り値のベクトルはすべてがTRUEになる。すべての要素が同じ（戻り値がすべてTRUE）か否かの判定には、all関数を使う。all関数は、要素がすべてTRUEならばTRUEを返す。すべての要素が異なる場合の判定は論理否定の演算子を追加する。すべての要素が同じか否かの判定は、setequal関数も使える。

> i <- c(1, 2, 3)
> j <- c(1, 2, 4)
> k <- c(1, 2, 3)
> all(i == j)
[1] FALSE
> all(i == k)
[1] TRUE
> !all(i == k)
[1] FALSE
> setequal(i, j)
[1] FALSE
> setequal(i, k)
[1] TRUE

互いの要素が一つでも同じ場合の判定には、any関数を使う。any関数は要素が一つでもTRUEの場合にTRUEを返す。

> i <- 1:3
> j <- c(1, 2, 4)
> k <- 4:6
> any(i == j)
[1] TRUE
> any(i == k)
[1] FALSE

二つのベクトルの要素の共通部分と和集合を得る

二つのベクトルのどちらにも属している要素（共通部分、A∩B）のベクトルを得るには、union関数を使う。

二つのベクトルの少なくとも一方に属している要素（和集合、A∪B）のベクトルを得るには、intersect関数を使う。

一方にしか属していない要素のベクトルを得るには、setdiff関数を使う。第一引数のベクトルの要素から、第二引数のベクトルに含まれる要素を取り除いたベクトルを返す。

> a <- 1:4
> b <- 3:7
> a
[1] 1 2 3 4
> b
[1] 3 4 5 6 7
> union(a, b)
[1] 1 2 3 4 5 6 7
> intersect(a, b)
[1] 3 4
> setdiff(a, b)
[1] 1 2
> setdiff(b, a)
[1] 5 6 7

要素にNAかNaNが含まれていないか簡単に確認する

anyNA関数を使う。引数に指定したものに1つでもNAかNaNが含まれているとTRUEを返す。関数名からしてNAだけと思われがちだが、NaNがあってもTRUEを返す。引数に与えるものはベクトルでも行列でもかまわない。

> d <- c(1, 2, 3)
> anyNA(d)
[1] FALSE
> d <- c(1, 2, NA)
> anyNA(d)
[1] TRUE
> d <- c(1, 2, NaN)
> anyNA(d)
[1] TRUE
> mx <- matrix(c(1, 2, 3, 4), 2, 2)
> mx
     [,1] [,2]
[1,]    1    3
[2,]    2    4
> anyNA(mx)
[1] FALSE
> mx <- matrix(c(1, 2, 3, NA), 2, 2)
> anyNA(mx)
[1] TRUE

無限大（Inf）は判定の対象にはならないことに注意。

> d <- c(1, 2, Inf)
> anyNA(d)
[1] FALSE

ベクトルに含まれるNAの個数を数える

sum関数とis.na関数を組み合わせると簡単に計算できる。

> d <- c(1, 2, NA, 4, NA)
> is.na(d)
[1] FALSE FALSE  TRUE FALSE  TRUE
> sum(is.na(d))
[1] 2
> sum(!is.na(d))
[1] 3

sum関数は論理型ベクトルを与えると、TRUEを1、FALSEを0と見なして計算するため（「Logical true values are regarded as one, false values as zero.」）、is.na関数でNAか否かの論理型ベクトルに変換してそれをsum関数に与えれば、ベクトルに含まれるNAの個数を簡単に求めることができる。

等差数列を作成する

seq関数を使う。第1引数には初項を指定する。第2引数は第3引数の指定により異なる。第3引数はデフォルトではbyオプションであり、byオプションは公差の指定で、初項から加算して第2引数を超えない値を末項にした等差数列を作成する。第3引数にlengthオプションを指定した場合は、第1引数と第2引数をそれぞれ初項、末項にして、指定した値が項数となる等差数列を作成する。

第1引数と第2引数は自動で比較され、byオプションで公差を明示しないと自動的に公差の正負が決められてしまうことに注意。第3引数を指定しないと自動的に公差は1,-1,0のいずれかになる。当然、実数も指定することができる。

> seq(1, 5)
[1] 1 2 3 4 5
> seq(1, 10, 3)
[1]  1  4  7 10
> seq(1, 12, 3)
[1]  1  4  7 10
> seq(1, 12, by = 3)
[1]  1  4  7 10
> seq(1, 12, length = 3)
[1]  1.0  6.5 12.0
> seq(1, -2)
[1]  1  0 -1 -2
> seq(-5, -5)
[1] -5
> seq(1, 1, length = 10)
 [1] 1 1 1 1 1 1 1 1 1 1
> seq(1.30, 1.22, by = -0.02)
[1] 1.30 1.28 1.26 1.24 1.22
> seq(1.30, 1.22, length = 4)
[1] 1.300000 1.273333 1.246667 1.220000

ベクトルのインデックスベクトルを作成する

seq_along関数は引数に指定したベクトルのインデックス（初項1、公差1、末項と項数がベクトルの長さの等差数列）となるベクトルを作成する。戻り値は1:length(v)（vはベクトル）と同じであり、これよりはシンプルな書き方をすることができる。

> s <- c("大橋彩香", "石見舞菜香", "優木かな", "和多田美咲")
> seq_along(s)
[1] 1 2 3 4
> 1:length(s)
[1] 1 2 3 4

ベクトルの要素が特定の値か否かの判定を行う

%in%演算子を使う。左側のベクトルの要素が右側のベクトルに含まれる場合はTRUE、そうでない場合はFALSEを返す。

> s <- c("大橋彩香", "石見舞菜香", "優木かな", "和多田美咲")
> s %in% "大橋彩香"
[1]  TRUE FALSE FALSE FALSE
> s %in% c("石見舞菜香", "和多田美咲")
[1] FALSE  TRUE FALSE  TRUE

ベクトルから条件に一致する要素を抽出する

ベクトルはインデックス（構成する要素に割り振られた1から始まる連番）の指定に、ベクトルと同じ長さの論理型ベクトルを与えると、ブール値がTRUEの要素だけを取り出すため、これを利用する。一致する要素が無い場合は、長さが0のベクトルを返す。

> n <- 2 ^ (0:12)
> print(n)
 [1]    1    2    4    8   16   32   64  128  256  512 1024 2048 4096
> n > 1000
 [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE
> n[n > 1000]
[1] 1024 2048 4096
> n[n > 10000]
numeric(0)
> length(n[n > 10000])
[1] 0
> ss <- c("鈴木みのり", "鈴木みのり", "瀬戸麻沙美", "のぐちゆり", "和多田美咲")
> ss[ss == "瀬戸麻沙美"]
[1] "瀬戸麻沙美"
> ss[ss == "鈴木みのり" | ss == "のぐちゆり"]
[1] "鈴木みのり" "鈴木みのり" "のぐちゆり"
> ss[grep("美", ss)]
[1] "瀬戸麻沙美" "和多田美咲"

ベクトルから条件に一致する要素のインデックスを抽出する

which関数を使う。一致する要素が無い場合は、長さが0のベクトルを返す。戻り値は、指定した条件に一致する要素のインデックス（構成する要素に割り振られた1から始まる連番）であり、要素そのものではないことに注意。

> n <- 2 ^ (0:12)
> print(n)
 [1]    1    2    4    8   16   32   64  128  256  512 1024 2048 4096
> which(n > 1000)
[1] 11 12 13
> which(n > 10000)
integer(0)
> length(which(n > 10000))
[1] 0
> ss <- c("鈴木みのり", "鈴木みのり", "瀬戸麻沙美", "のぐちゆり", "和多田美咲")
> which(ss == "瀬戸麻沙美")
[1] 3
> which(ss == "鈴木みのり" | ss == "のぐちゆり")
[1] 1 2 4

ベクトルに特定の要素が含まれているかどうか調べる

is.element関数を使う。第一引数に含まれているかどうか調べたい要素を、第二引数には調べる対象の集合をベクトルで指定する。調べたい要素は複数同時に指定できる。%in%演算子を使っても同じ結果が得られる。

> chara <- c("ルアン・メェイ", "帰忘の流離人", "イレイナ", "アストラ")
> is.element("キャストリス", chara)
[1] FALSE
> is.element("ルアン・メェイ", chara)
[1] TRUE
> is.element(c("アストラ", "ホタル", "帰忘の流離人"), chara)
[1]  TRUE FALSE  TRUE
> c("アストラ", "ホタル", "帰忘の流離人") %in% chara
[1]  TRUE FALSE  TRUE

ベクトルの要素すべてが同じかどうか調べる

setequal関数を使う。指定した2つのベクトルの要素がまったく同じであればTRUEを返す。集合として等しいかどうかを判定しており、最後の例のとおり、要素の順番が異なっても属する要素が同じであればTRUEを返す。

> chara1 <- c("ルアン・メェイ", "帰忘の流離人", "イレイナ")
> chara2 <- c("ルアン・メェイ", "帰忘の流離人", "イレイナ", "アストラ")
> setequal(chara1, chara2)
[1] FALSE
> chara2 <- c("ルアン・メェイ", "帰忘の流離人", "イレイナ")
> setequal(chara1, chara2)
[1] TRUE
> chara2 <- c("イレイナ", "ルアン・メェイ", "帰忘の流離人")
> setequal(chara1, chara2)
[1] TRUE

2組のベクトルの各要素同士によるすべての組合せによる演算結果を得る

outer関数もしくは%o%演算子を使う。outer関数は特に演算子を指定しなければ積を計算する。%o%演算子も積を計算する。これを和や差にしたい場合はouter関数の第三引数に、その演算子を指定する。戻り値は行列。行と列を入れ替えたければt関数を使えばよい。第三引数には関数を与えてもよい。

> x <- c(1, 2, 3)
> y <- c(10, 20, 30, 40)
> outer(x, y)
     [,1] [,2] [,3] [,4]
[1,]   10   20   30   40
[2,]   20   40   60   80
[3,]   30   60   90  120
> x %o% y
     [,1] [,2] [,3] [,4]
[1,]   10   20   30   40
[2,]   20   40   60   80
[3,]   30   60   90  120
> outer(x, y, "+")
     [,1] [,2] [,3] [,4]
[1,]   11   21   31   41
[2,]   12   22   32   42
[3,]   13   23   33   43
> outer(x, y, "-")
     [,1] [,2] [,3] [,4]
[1,]   -9  -19  -29  -39
[2,]   -8  -18  -28  -38
[3,]   -7  -17  -27  -37
> outer(x, y, "-") |> t()
     [,1] [,2] [,3]
[1,]   -9   -8   -7
[2,]  -19  -18  -17
[3,]  -29  -28  -27
[4,]  -39  -38  -37
> f <- function(x, y) {x ^ 2 + y ^ 3}
> outer(x, y, f)
     [,1] [,2]  [,3]  [,4]
[1,] 1001 8001 27001 64001
[2,] 1004 8004 27004 64004
[3,] 1009 8009 27009 64009

複数の各ベクトルの要素同士によるすべての組合せを作成する

expand.gridを使う。戻り値はデータフレーム。

> s1 <- c("ルアン・メェイ", "帰忘の流離人", "キャストリス")
> s2 <- c("セナディア", "ヘリア")
> s3 <- c("カンタレラ", "シャコンヌ")
> expand.grid(h3 = s1, hr = s2)
              h3         hr
1 ルアン・メェイ セナディア
2   帰忘の流離人 セナディア
3   キャストリス セナディア
4 ルアン・メェイ     ヘリア
5   帰忘の流離人     ヘリア
6   キャストリス     ヘリア
> expand.grid(h3 = s1, hs = s2)
              h3         hs
1 ルアン・メェイ セナディア
2   帰忘の流離人 セナディア
3   キャストリス セナディア
4 ルアン・メェイ     ヘリア
5   帰忘の流離人     ヘリア
6   キャストリス     ヘリア
> expand.grid(h3 = s1, hs = s2, ww = s3)
               h3         hs         ww
1  ルアン・メェイ セナディア カンタレラ
2    帰忘の流離人 セナディア カンタレラ
3    キャストリス セナディア カンタレラ
4  ルアン・メェイ     ヘリア カンタレラ
5    帰忘の流離人     ヘリア カンタレラ
6    キャストリス     ヘリア カンタレラ
7  ルアン・メェイ セナディア シャコンヌ
8    帰忘の流離人 セナディア シャコンヌ
9    キャストリス セナディア シャコンヌ
10 ルアン・メェイ     ヘリア シャコンヌ
11   帰忘の流離人     ヘリア シャコンヌ
12   キャストリス     ヘリア シャコンヌ
> class(expand.grid(h3 = s1, hs = s2, ww = s3))
[1] "data.frame"

複数の各ベクトルの要素同士によるすべての組合せを作成する

tidyrパッケージ（tidyverseパッケージに含まれている）のexpand_gridを使う。戻り値はtibble。以下では簡潔な表示にするためデータフレームに変換して表示している。

> s1 <- c("ルアン・メェイ", "帰忘の流離人", "キャストリス")
> s2 <- c("セナディア", "ヘリア")
> s3 <- c("カンタレラ", "シャコンヌ")
> library(tidyr)
> expand_grid(h3 = s1, hs = s2) |> as.data.frame()
              h3         hs
1 ルアン・メェイ セナディア
2 ルアン・メェイ     ヘリア
3   帰忘の流離人 セナディア
4   帰忘の流離人     ヘリア
5   キャストリス セナディア
6   キャストリス     ヘリア
> expand_grid(h3 = s1, hs = s2, ww = s3) |> as.data.frame()
               h3         hs         ww
1  ルアン・メェイ セナディア カンタレラ
2  ルアン・メェイ セナディア シャコンヌ
3  ルアン・メェイ     ヘリア カンタレラ
4  ルアン・メェイ     ヘリア シャコンヌ
5    帰忘の流離人 セナディア カンタレラ
6    帰忘の流離人 セナディア シャコンヌ
7    帰忘の流離人     ヘリア カンタレラ
8    帰忘の流離人     ヘリア シャコンヌ
9    キャストリス セナディア カンタレラ
10   キャストリス セナディア シャコンヌ
11   キャストリス     ヘリア カンタレラ
12   キャストリス     ヘリア シャコンヌ
> expand_grid(h3 = s1, hs = s2, ww = s3) |> class()
[1] "tbl_df"     "tbl"        "data.frame"

様々な形式

ロウ型ベクトルの値を置換する

[ ]演算子を利用する。以下は、ヌル（0x00）を空白（0x20）に置換する例。

> ch <- c(0x41:0x43, 0x00, 0x61:0x63, 0x00, 0x31:0x33)
> ra <- as.raw(ch)
> rawToChar(ra)
 rawToChar(ra) でエラー: 
   文字列の中に nul が埋め込まれています: 'ABC\0abc\0123' 
> ra[ra == as.raw(0x0)] <- as.raw(0x20)
> rawToChar(ra)
[1] "ABC abc 123"

ベクトルの要素をランダムに抽出する

sample関数を使う。引数にベクトルだけを与えると、要素をランダムに並び替えたベクトルを返す。第2引数に数値を指定すると、その数だけランダムに要素を選んだベクトルを返す。デフォルトでは非復元抽出（一度抜き取った標本を元に戻さずに次の標本を抽出すること）のため、与えたベクトルの要素数以上の値を指定すると、選べないためエラーが発生する。

> s <- c("A", "B", "C", "D", "E")
> sample(s)
[1] "D" "B" "A" "E" "C"
> sample(s)
[1] "B" "C" "E" "D" "A"
> sample(s, 3)
[1] "B" "E" "A"
> sample(s, 3)
[1] "D" "E" "C"
> sample(s, 6)
 sample.int(length(x), size, replace, prob) でエラー: 
   'replace = FALSE' なので、母集団以上の大きさの標本は取ることができません

replaceオプションにTRUEを指定すると復元抽出（一度抜き取った標本を元に戻してから次の標本を抽出すること）になる。そのため、返されるベクトルの要素には重複が生じる。また、与えたベクトル以上の要素数を超える数値を指定してもランダムに選ばれて返される。

> sample(s, 3, replace = TRUE)
[1] "C" "E" "D"
> sample(s, 3, replace = TRUE)
[1] "B" "E" "E"
> sample(s, 6, replace = TRUE)
[1] "A" "D" "B" "C" "A" "A"

sample関数は乱数の処理に基づいて要素を抽出しており、特に指定をしなければ要素はランダムに選ばれ続ける。他の乱数の関数と同様に動作確認で乱数の発生を再現したい場合は、実行前にset.seed関数に適当な数値を指定して実行すればよい。同じ数値を指定してset.seed関数を実行すれば、乱数の発生を再現することができる。

> sample(s, 3, replace = TRUE)
[1] "E" "B" "E"
> sample(s, 3, replace = TRUE)
[1] "E" "D" "A"
> set.seed(3)
> sample(s, 3, replace = TRUE)
[1] "E" "B" "D"
> sample(s, 3, replace = TRUE)
[1] "D" "B" "C"
> set.seed(3)
> sample(s, 3, replace = TRUE)
[1] "E" "B" "D"
> sample(s, 3, replace = TRUE)
[1] "D" "B" "C"

ベクトルの要素について集計する

table関数を使うと、ベクトルの要素に含まれる値を集計することができる。以下は英大文字を復元抽出で32個選び、それを集計した例。戻り値はテーブル型になる。

> LETTERS
 [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P"
[17] "Q" "R" "S" "T" "U" "V" "W" "X" "Y" "Z"
> s <- sample(LETTERS, 32, replace = TRUE)
> print(sort(s))
 [1] "A" "C" "C" "D" "D" "G" "H" "H" "J" "K" "L" "L" "M" "M" "O" "O"
[17] "Q" "Q" "Q" "R" "U" "V" "V" "V" "W" "W" "W" "W" "X" "Y" "Y" "Z"
> tab <- table(s)
> print(tab)
s
A C D G H J K L M O Q R U V W X Y Z 
1 2 2 1 2 1 1 2 2 2 3 1 1 3 4 1 2 1 
> tab['A']
A 
1 
> tab[c('A', 'Q')]
s
A Q 
1 3 
> class(tab)
[1] "table"
> as.data.frame(tab)
   s Freq
1  A    1
2  C    2
3  D    2
4  G    1
5  H    2
6  J    1
7  K    1
8  L    2
9  M    2
10 O    2
11 Q    3
12 R    1
13 U    1
14 V    3
15 W    4
16 X    1
17 Y    2
18 Z    1

要素を一つも持たない空のベクトルを作る

要素にNULL指定して代入すればよい。

> s <- c(NULL)
> print(s)
NULL
> length(s)
[1] 0

空のベクトルが何の役に立つかというと、制御構文の都合でベクトルに値を代入だけをしたい場合は、最初に空にしておくことで、要素を代入する式のみ書けばいいことになり、すっきりしたスクリプトを書くことができる。

> s <- c(NULL)
> c(s, "鈴木みのり", "セナディア")
[1] "鈴木みのり" "セナディア"
> n <- c(NULL)
> print(n)
NULL
> for (i in 1:3) {n <- c(n, i)}
> print(n)
[1] 1 2 3

ベクトルの先頭部分の要素を取り出す

head関数を使う。先頭から取り出したい要素の個数を指定する。個数に負数を指定すると「末尾から○個取り除いた先頭部分」という指定になる。デフォルトで個数は6が割り当てられており、コマンドラインでさっと中身を確認したいときなどに利用すると便利。

> ss <- c("帰忘の流離人", "キャストリス", "ホタル", "ルアン・メェイ")
> head(ss, 2)
[1] "帰忘の流離人" "キャストリス"
> ss |> head(3)
[1] "帰忘の流離人" "キャストリス" "ホタル"      
> ss |> head(-1)
[1] "帰忘の流離人" "キャストリス" "ホタル"      
> ss |> head(-2)
[1] "帰忘の流離人" "キャストリス"
> n <- 2 ^ (1:16)
> n |> head()
[1]  2  4  8 16 32 64

ベクトルの重複する要素を取り出す（取り除く）

duplicated関数は、ベクトルを与えると重複する要素についてTRUEを返す。インデックスの少ないほうから調べて、最初に含まれる要素はFALSEを返し、それ以降登場した要素についてはTRUEを返す。これをベクトルのインデックスに指定すれば、その重複する要素を取り出せる（取り除ける）。which関数を組み合わせるとインデックスを得ることができる。インデックスの多いほうから判定するにはfromLastにTRUEを指定する。

> x <- c(20, 40, 10, 20, 30, 40, 40, 50, 60)
> x
[1] 20 40 10 20 30 40 40 50 60
> duplicated(x)
[1] FALSE FALSE FALSE  TRUE FALSE  TRUE  TRUE FALSE FALSE
> x[duplicated(x)]
[1] 20 40 40
> x[!duplicated(x)]
[1] 20 40 10 30 50 60
> which(duplicated(x))
[1] 4 6 7
> which(!duplicated(x))
[1] 1 2 3 5 8 9
> data.frame(x, duplicated(x))
   x duplicated.x.
1 20         FALSE
2 40         FALSE
3 10         FALSE
4 20          TRUE
5 30         FALSE
6 40          TRUE
7 40          TRUE
8 50         FALSE
9 60         FALSE
> data.frame(x, duplicated(x, fromLast = TRUE))
   x duplicated.x..fromLast...TRUE.
1 20                           TRUE
2 40                           TRUE
3 10                          FALSE
4 20                          FALSE
5 30                          FALSE
6 40                           TRUE
7 40                          FALSE
8 50                          FALSE
9 60                          FALSE

重複が生じている要素すべてを取り出す（すべて取り除く）には、%in%演算子とduplicated関数と[ ]を組み合わせることで実現できる。

> x
[1] 20 40 10 20 30 40 40 50 60
> x[x %in% x[duplicated(x)]]
[1] 20 40 20 40 40
> which(x %in% x[duplicated(x)])
[1] 1 2 4 6 7
> x[!(x %in% x[duplicated(x)])]
[1] 10 30 50 60
> which(!(x %in% x[duplicated(x)]))
[1] 3 5 8 9

ベクトルの末尾部分の要素を取り出す

tail関数を使う。末尾から取り出したい要素の個数を指定する。個数に負数を指定すると「先頭から○個の取り除いた末尾部分」という指定になる。デフォルトで個数は6が割り当てられており、コマンドラインでさっと中身を確認したいときなどに利用すると便利。

> ss <- c("帰忘の流離人", "キャストリス", "ホタル", "ルアン・メェイ")
> tail(ss, 2)
[1] "ホタル"         "ルアン・メェイ"
> ss |> tail(3)
[1] "キャストリス"   "ホタル"         "ルアン・メェイ"
> ss |> tail(-1)
[1] "キャストリス"   "ホタル"         "ルアン・メェイ"
> ss |> tail(-2)
[1] "ホタル"         "ルアン・メェイ"
> n <- 2 ^ (1:16)
> n |> tail()
[1]  2048  4096  8192 16384 32768 65536

ベクトルの指定の条件を満たす要素だけを書き換える

[ ]を使用して論理型ベクトルを与えて代入すればよい。与える論理型ベクトルは、値を書き換えるベクトルと同じ長さである必要がある。最後の例のとおり、式を直接[ ]内に書いてもよく、元の値を新しい値の計算に使うこともできる。

> n <- 1:10
> n
 [1]  1  2  3  4  5  6  7  8  9 10
> bo <- n >= 2 & n < 7
> bo
 [1] FALSE  TRUE  TRUE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE
> n[bo] <- 100
> n
 [1]   1 100 100 100 100 100   7   8   9  10
> n <- 1:10
> n
 [1]  1  2  3  4  5  6  7  8  9 10
> n[n > 6] <- n[n > 6] * 100
> n
 [1]    1    2    3    4    5    6  700  800  900 1000

ベクトルの要素にNAが含まれているかどうか調べる

anyNA関数を使う。ベクトルに一つでもNAが含まれるとTRUEを返す。

> anyNA(1)
[1] FALSE
> anyNA(NA)
[1] TRUE
> anyNA(c(1, 2, 3, 4))
[1] FALSE
> anyNA(c(1, 2, NA, 4))
[1] TRUE
> anyNA(c(NA, NA, NA, NA))
[1] TRUE

ベクトルの要素がすべてTRUEかどうか調べる

all関数は引数に与えたベクトルの要素がすべてTRUEの場合、TRUEを返す。これを応用させると、例えば引数に比較演算子を使用したベクトルの演算を指定すれば、そのベクトルの要素が指定の条件を満たしているかどうかという判定に使うことができる。

> all(TRUE)
[1] TRUE
> all(c(TRUE, TRUE))
[1] TRUE
> all(c(TRUE, TRUE, FALSE))
[1] FALSE
> all(c(1, 2, 3) > 0)
[1] TRUE
> all(c(1, 2, 3) > 1)
[1] FALSE
> all(c(1, 2, 3) > 4)
[1] FALSE

ベクトルの要素にTRUEが含まれているかどうか調べる

any関数は引数に与えたベクトルの要素にTRUEが一つでも含まれるとTRUEを返す。これを応用させると、例えば引数に比較演算子を使用したベクトルの演算を指定すれば、そのベクトルの要素が指定の条件を満たしているかどうかという判定に使うことができる。

> any(TRUE)
[1] TRUE
> any(c(TRUE, TRUE))
[1] TRUE
> any(c(TRUE, TRUE, FALSE))
[1] TRUE
> any(c(1, 2, 3) > 0)
[1] TRUE
> any(c(1, 2, 3) > 1)
[1] TRUE
> any(c(1, 2, 3) > 4)
[1] FALSE