ベクトル - R入門

目次

基本操作

ベクトルとは

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つも持たないベクトルを作成している。

ベクトルに値を代入する

代入演算子<-を使う。

> 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にあらかじめ組み込まれている（起動直後に使える）定数は、5つある。

LETTERS（英大文字）
letters（英小文字）
month.abb（月名の略語）
month.name（月名）
pi（円周率）

> LETTERS
 [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O"
[16] "P" "Q" "R" "S" "T" "U" "V" "W" "X" "Y" "Z"
> letters
 [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o"
[16] "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"
> month.abb
 [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct"
[11] "Nov" "Dec"
> month.name
 [1] "January"   "February"  "March"     "April"     "May"      
 [6] "June"      "July"      "August"    "September" "October"  
[11] "November"  "December" 
> pi
[1] 3.141593

これらはRでは、あらかじめ用意されているベクトルでしかなく、予約語ではない。よって、異なる値を代入することができる（書き換えることができる）ため、注意すること。

> pi
[1] 3.141593
> pi <- 3.13
> pi
[1] 3.13

要素の操作

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

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

様々な形式

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

[ ]演算子を利用する。以下は、ヌル（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