統計処理ソフト R 入門 講習会資料

ユーザから見た R の長所

• 最先端の議論を踏まえた統計解析
• 強力な作図機能
• 豊富な追加パッケージ
• R 言語の高い記述力
• ウェブ上の情報が主
• GNU GPL

ユーザから見た R の短所

• 初心者が，たとえ統計学の知識があったとしても，すぐに使い始められるものではない

ブロック

{ } で囲むことで，複数の表現式を１つにまとめることができます。 まとめてできたものも表現式です。よって，それを評価した結果は全体として１つの値が得られます。 ブロックの中に複数の表現式がある場合，最後の表現式の値がブロック全体の値となります。

{
  4 * 5
  (x <- 4 * 5)    # ( ) をつけてもprint()されない
  sqrt(3) + x
}

{ log2(4); 5 ^ 2 } * 3

表現式オブジェクト

直接入力したステートメントを解析してできた表現式だけでなく， R は R 上の文字列データから動的に表現式を作ることができます （R では表現式もオブジェクトとして扱えます）。 次のコードは，文字列から表現式オブジェクトを生成するサンプルです。

str1 <- "1 + 2 ^ 3 / sqrt(4)"  # 文字列を作成
str1
expr1 <- parse(text=str1)      # 文字列を表現式に
expr1
eval(expr1)                    # 表現式を評価

• ?parse
• ?deparse

expression() 関数を使うと，表現式を評価しないまま表現式オブジェクトとしてとっておくことができます。 これは後述の関数呼び出しオブジェクトと非常に似ています。

expr2 <- expression( (5:8)[-3] * 2 )  # 表現式オブジェクトを作成
expr2
eval(expr2)                           # 評価する

これは自前の関数を書く際のテクニックとしてだけでなく， 導関数を得るときやグラフに数式を描くときなどにも活用されます。

• ?expression
• ?deriv
• 関数呼び出し

遅延評価

R では，基本的に，入用にならなければ表現式は評価されません。 例えば，関数内部で使われない引数は，そこへ表現式（e.g., 1+1 ） を渡していても一度も評価されないまま（1+1が計算されないまま），その関数の実行を終えます。 これが R における遅延評価(lazy evaluation)です。

下はこの働きを確かめるためのサンプルです。どうしてこのような出力になるのか考えてみてください。

f <- function(x={print("x!");2}, y={print("y!");0}, z={print("z!");8}) {
  if (y != 0) {
    return(z + 1)
  }
  return(x)
}

f()
f(z=f())
f(y=f())
f(x=f())
f(x=f(), y=1)

この機能は，R の実行速度に一役買っていますが，ユーザは関数を呼び出す際に注意しなければなりません。 引数には，何らかの変数の値を書き換えうるような表現式を書かないようにしましょう。

x <- c("A", "B", NA, "D")
mean(x, na = myNA <- TRUE)  # myNA は作成されない
myNA
x <- c(1, 2, NA, 4)
mean(x, na = myNA <- TRUE)  # myNA が作成される
myNA

代入と削除

x <- 5 + 6    # 結果を代入
x * 10        # xに入っている値に10をかける

<- は代入（assign; 付値とも呼ばれる）を行う演算子です。-> や = も使えますが，おすすめしません。 演算子 = は，<- や -> と異なり，使用可能な場所が限定されています。 また，優先順位は3つの中で -> が最も高く，次に = ，一番低いのが <- です。 例では 5 + 6 を計算した結果のオブジェクトを x に代入しています。 以後，x という名前でそのオブジェクトを参照できます。

この x は変数と呼ばれます。中身を入れ替えることができるからです。

x <- 5 + 1  # x は 6
x
x <- 3 - 2  # x の中身を 1 に変更
x

入れ替えたら，もう元のオブジェクトを参照できません。このミスはよく起こります。 大事なデータを無くさないよう気をつけてください。

次のように，変数から変数への代入も可能です。

x <- 4
y <- x  # x の中身を y へ
y

注意しなければならないのは，R では基本的に，代入はオブジェクトのコピーを作成します。 代入で複製された一方の変数の値を変更しても，もう一方の変数の値は変わりません。 環境オブジェクトは特別で，代入してもコピーされません。 実装レベルでもコピーしているかどうかは別問題。さすがに実装は copy-on-write です。

x <- c(3, 1, 2)
y <- x
y[2] <- 5
y  # y の値は変更されている
x  # x はそのまま

名前をつけて確保したオブジェクト（変数の値）は，システムによって「まだ必要」と見なされるので，たくさんのオブジェクトを 名前をつけて置いておくとそのうち利用可能なメモリ容量をオーバーしてしまうかもしれません。 ですので，名前をつけたものについては，もう要らなくなったら削除して（名前を消して）いくように心がけます。 削除には rm() 関数を使います。

rm(x)  # xを削除

現在の環境に存在するオブジェクトの一覧を得るには ls() 関数を使います。 特定の名前のオブジェクトが存在するかどうかは exists() 関数で調べられます。

x <- 3
y <- "Hello"
z <- TRUE
ls()         # 存在するオブジェクトの名前を一覧
exists("y")  # y という名前のついたオブジェクトが存在するかどうか

rm() は list という引数に名前のベクトルを渡すことで複数のオブジェクトを一気に削除できるので， これと ls() を組み合わせて全部のオブジェクトを一度に消すことができます。

rm(list=ls())   # ただしこれでは隠しオブジェクトは消えない

R をうまく活用するには，このように複数の関数を組み合わせるテクニックが重要です。

内容の表示

オブジェクトの名前だけの表現式を評価すると，オブジェクトの内容が表示されます。

myobj <- c(6, 3, 5, 8, 4)
myobj                    # myobj の内容を表示

これは暗黙にprint()という関数を呼び出しているのと同じことです。

print(myobj)

表現式は１つ以上の複合的な関数呼び出しであり，各関数を呼び出して戻り値を得るということを繰り返していった結果， 最終的に１つの値（オブジェクト）になります。 ということは，どんな表現式も，最後には上のようなオブジェクトだけの式になり， 最後にそれを評価することでコンソールに内容が出力されるはずです。 しかし，評価してもコンソール出力のない表現式もあります。代表的には，

x <- 3 ^ -1

などがそうです。代入の評価は例外的に値を返さないのでしょうか？そんなことはありません。ではどういう事かというと， 関数の戻り値には print() されるかどうかの指定ができ（これは可視性visibilityと呼ばれます）， このような関数では自動的に print() しない指定(invisible)がされているのです。

こういう不可視(invisible)な戻り値の場合にも，オブジェクトの内容を print() させるテクニックがあります。

(x <- 3 ^ -1)

( ) で囲むことで，戻り値を可視(visible)にできます。"(" も実は一種の関数です。 他にも作図関数など戻り値が print() されないものは多くありますが， 全体を ( ) で囲めば print() させることができます。

• ?"("

型

オブジェクトには型(type)があります。型とは，オブジェクトが持っているデータの種類です。 Rでは，他の言語(例えばC)のような変数の型はありません。R の変数は，いわゆるバリアントです。 typeof() 関数を使って型の情報を得ることができます。

x <- 2
typeof(x)
x <- "abc"
typeof(x)
x <- 1:4
typeof(x)
x <- list(2, "abc")
typeof(x)

同じくデータの種類についての情報ですが，型よりも抽象的なものとして， オブジェクトはモード(mode)も持っています。 型の情報は，R の実装に深く関係しており，R の通常の使用ではモードの情報で十分なので，こちらを利用します。 モードを得るには mode() 関数を使います。

x <- 2
mode(x)
x <- "abc"
mode(x)
x <- 1:4
mode(x)
x <- list(2, "abc")
mode(x)

モードよりももう少し詳細な情報（型との中間のような位置づけ）として，保管モード(storage mode)があります。 モードでは隠蔽されてしまうメモリへの格納方法(例えば integer と double)を区別することができます。 保管モードは storage.mode() 関数で得られます。

モードと保管モードは，実装とは距離を置いた R 言語上での抽象的情報であり，変更するための記法も柔軟になっています。

x <- 2
x
mode(x) <- "character"
x

Rには原子型(atomic types, atomic vector types)と呼ばれる基本的な型がいくつかあります。 下の表はそのうちの主なものです(すべてではない)。

これらの原子型は，表中の上へいくほどその型のオブジェクトが持つ情報が少なくなります。 R では，別々の型のオブジェクトを１つの型にそろえなければならない場合， 情報を保存するために表中の下方にある型へそろえるよう自動的に変換(coerce)します。

(x <- c(TRUE, 3))
typeof(x)
(x <- c(TRUE, 3, "OK"))
typeof(x)

属性

あらゆるオブジェクトには属性(attributes)をつけることができます。 属性とは，オブジェクトのメインの情報（データ）を補助するサブ情報のようなものです。 ある種類のデータ構造を持つオブジェクト（例えば行列など）には必然的に付いている属性もありますし， ユーザが自分の好きな名前の属性を任意のオブジェクトに付加することもできます。

(x <- data.frame(matrix(1:6, nrow=3)))
attributes(x)                                     # このオブジェクトの属性を一覧
attr(x, "names")                                  # "names"属性を取得
attr(x, "my.attribute") <- c("A", "E", "I", "O")  # 新しい属性を付加
attributes(x)
attributes(x) <- NULL                             # 属性をすべて消す

Rのオブジェクトの振舞いの多様性を支える様々なものがこの属性の仕組みに依拠しています。 行列や配列の次元，リストやデータフレームの要素名，ベクトルや行列の行ラベルや列ラベル， ファクターの水準，S3クラス，などなど。

戻り値

Rでは，すべての関数は戻り値(return value; 返り値とも呼ばれる)を返します。 返ってくるのは常にオブジェクトです（ただし様々な型があり得ます）。

関数呼び出しとは，表現式の中でその関数が書いてある部分を戻り値で置き換えること， とイメージするとわかりよいかもしれません。

引数

関数は０個以上の引数(arguments)を取ることができます。 引数は関数へのインプットであり，関数を呼び出すときに引数の値を変えることで関数の戻り値や副作用を変化させられます。

ある関数が１つ以上の引数を取るものと定義されている場合，各引数には別々の名前が付いています。 引数の名前や，その引数が何を意味しているか，それぞれの引数が要求する型は何か，などは関数によって異なります。 関数の引数名の一覧は args() 関数で得られますが， それだけの情報では役に立たないので，初心者は help() 関数って引数の意味を調べましょう。

引数に関しては，仮引数(formal arguments)と実引数(actual arguments)を区別する必要があります。 仮引数とは，関数定義において使われているシンボルです。実引数とは，呼び出し時にそのシンボルに当てられた値です。

引数にはデフォルト値(default value)が定義されているものと，そうでないものがあります。 デフォルト値を持つ引数は，呼び出しのときに値の指定を省略することができ，その場合にデフォルト値が用いられます。 デフォルト値を持たない引数は，多くの場合，省略できません（ただし例外はあります）。 デフォルト値の定義されていない引数だからといって，必ず指定しなければならない訳ではありません。 関数の内容を評価する際にその引数が用いられなければ問題はありませんから，実引数を渡さなくても場合によってはエラーが出ないときもあります。

mydata <- c(2, 3, 6, 4, NA, 8)
median(x=mydata)  # na.rm 引数は省略されており，デフォルトの FALSE が用いられる

R言語における実引数の記述方法はとても柔軟です。 どの値がどの引数に割り当てられるかは次の順で決められます。

1. 名前指定つきで渡されている実引数は，その名前に当てはまる仮引数が探し出され，そこに割り当てられます。
2. 名前指定されているけれどもそれに完全に一致するものがない場合，部分的に一致（前方一致）する名前があれば，その仮引数に割り当てられます。 名前指定されているのに部分一致すらしないときは，エラーになります。
3. 名前指定つきを割り当て終わったら，名前の指定されていないものを残っている仮引数の前から順番に割り当てます。
4. すべての仮引数に割り当て終わってもまだ実引数が残っている場合，もし関数が"..."引数を持っているならすべてそこへ割り当てられます。 もしもっていなければ，エラーになります。

# mean(x, trim = 0, na.rm = FALSE, ...)  # mean()関数の引数
a <- c(4,6,2,7,4,5,NA,2,4,2,6,3,2,2,5,1)
mean(trim = 0.1, na.rm = TRUE, x = a)  # 全部名前を指定しているので並べる順序は関係ない
mean(a, na.rm = TRUE, 0.1)             # a は x に，0.1 は trim に割り当てられる
mean(na = TRUE, a)                     # na は na.rm の省略と見なされる. trim はデフォルト値

"..."(dot-dot-dot)は特別な意味を持つ引数です。簡単に言えば「その他すべて」という意味で， 主に，ある関数内で他の関数を呼び出す際に引数を丸ごと引き渡すのに利用されます。 例えばplot()などの作図関数で活用されています。

関数の定義

function() を使うことで，自分で関数を定義できます。

function(引数リスト) 表現式

表現式の部分はブロックを使うことで複数行にできます（たいていの関数は複数行です）。 しかし，１つの表現式で済む場合は，表現式部分を { } で囲む必要はありません。

plus <- function(x, y = 1) { x + y }  # この場合，{ } は必要ない
plus(10, 20)
plus(10)

myfunc <- function(x = 0, y, z=10) {
  x <- x * 2
  (x + y) ^ z
}
myfunc(10, 20)
myfunc(10)    # エラー
myfunc(y=10)  # これならOK

function()が返すのは関数オブジェクトです。 これを変数に代入すれば関数に名前をつけることになりますが，名前をつけなくても関数を使う（呼び出す）ことはできます。 名前をつけられていない関数は匿名関数(anonymous function)と呼ばれます。

クロージャ

R では関数はおおきく３種類に分けられます: クロージャ (closure)，組み込み関数 (builtin functions)，特殊関数 (special functions)です。

組み込み関数と特殊関数は print() しようとすると .Primitive("...") や .Internal(...) という表示がされ，その内容が R 上で見えなくなっています。 組み込み関数と特殊関数の違いは，その引数を評価するかしないか（前者は評価して値を内部関数に渡す，後者は評価しないで渡す）です。 R 上では， typeof() 関数を用いることで組み込み関数と特殊関数を見分けることが可能です。 .Internal と .Primitive の違いは，.Primitive のほうが引数渡しの効率がよいことです。 .Internal のほうがより複雑なことをしていますが，そのおかげで名前での引数指定や可変長引数が実現されています。 .Primitive は位置でしか引数を区別できません。よって複数の引数をとる関数の実装に .Primitive を用いるのは非推奨になっています。 基礎的な演算子や制御構造，I/Oなど，R 言語の基盤的機能をもたらす関数が，この組み込み関数や特殊関数として実装されています。

これら以外の一般的な関数はすべて，クロージャです。クロージャとは，関数自体（仮引数 formals と定義内容 body ）とそれに結びつけられた環境 environment との組です。 関数を作ったときに，関数定義を行った環境が自動的に結びつけられ，クロージャとなります。 よってクロージャの含む環境は，その後にその関数の呼び出しを行う環境とは異なっているかもしれませんので，注意が必要となる場合があります。 関数定義を行った環境オブジェクトは，クロージャとして結びつけられているために「使用中」となり，その関数(クロージャ)が消されるか， 意図的な操作で関数と切り離されるか，関数と環境があわせて孤立するかしないと，環境は消えません。そうすると，その環境の中のオブジェクトも残り続けます。 R では関数内部で参照される個々の変数ではなく親環境まるごとをクロージャとして結びつけるので，親環境内の使われない変数もガベージコレクションされません。 また，環境オブジェクトはコピーされないという規則に合致して，エンクローズもコピーではなく参照なので，関数定義の後に親環境の変数値を書き換えることで関数の振る舞いが変わります。

• レキシカルスコープ

関数呼び出し

通常，関数を呼び出すことを表す表現式は，関数名の後に () を付けるだけです。必要ならその()内に引数を書きます。

proc.time()
mean(1:10)

Rでは，関数(function)だけでなく関数呼び出し(call)もオブジェクトです。 関数呼び出しオブジェクトを得る一番簡単な方法は，quote()関数です。

x <- quote(sqrt(2 + 7))  # quote()の引数の表現式は評価されず，callオブジェクトを作る
x
mode(x)
eval(x)  # 呼び出しを実行

関数呼び出しオブジェクトはリスト構造をしています。 リストの最初の要素は関数名のシンボル，２つ目以降の要素は引数を表します。

(x <- quote(sqrt(2 + 7)))
length(x)  # 2 が返る
x[[1]]
x[[2]]
length(x[[2]])  # 3 が返る
x[[2]][[1]]
x[[2]][[2]]
x[[2]][[3]]
x[[2]][[1]] <- as.name("rep")  # 一部を書き換え
x
eval(x)

• ?call
• ?quote
• ?substitute
• ?bquote

再帰

関数の中で自分自身を呼び出す再帰関数を作りたい場合，素朴には，

myfunc <- function(x) {
  if (x == 1)
    1
  else
    x * myfunc(x - 1)
}
myfunc(5)

このように作るかもしれませんが，これだとコードが関数につけた名前に依存しているので，関数の名前を変更してしまうと動かなくなります。

yourfunc <- myfunc
rm(myfunc)
yourfunc(5)

Recall() を使うことで，名前に依存せずに再帰関数を作ることができます。

myfunc <- function(x) {
  if (x == 1)
    1
  else
    x * Recall(x - 1)
}
myfunc(6)
yourfunc <- myfunc
rm(myfunc)
yourfunc(6)

# 匿名関数でもOK
(function(x){
  if (x <= 0)
    0
  else
    x + Recall(x - 1)
})(7)

演算子

R における基本的な演算子の一覧はヘルプにありますので参照してください。

R では，演算子(operators)も実は関数です。 演算子は構文解析において特別視され，トークンの特殊な配置が許されているだけです。

3 + 5      # 通常の表記
"+"(3, 5)  # 関数呼び出しと同じ表記. これでも動作する

典型的な演算子だけでなく， [ ] や ( ) なども同様に関数です。

x <- matrix(1:6, nrow=2)
"["(x, , 2)   # x[,2] と同じ

5 + 6   # 普通の足し算
"+" <- function(x, y) x * y   # +演算子を上書き
5 + 6   # ???
rm("+")

3 %m% 8   # エラー
"%m%" <- function(x, y) (x + y) / 2
3 %m% 8

?Syntax

基本的な関数

基本的で代表的な関数をリストアップしておきます。 もちろんこれがすべてではありません。 とくに，下にリストした関数のヘルプを参照すれば，それぞれに関連した関数などを見つけることができるはずです。

行列に対してふつうの演算子( * など)を使うと，成分ごとの計算をするので注意してください。

(x <- matrix(1:4, nrow=2))
(y <- matrix(5:8, nrow=2))
x %*% y
x * y

ベクトル化

多くの関数（とくに，基本的な関数）はベクトル化(vectorize)されています。 ベクトル化とは，引数に１つの値ではなくベクトルを渡したときに， 要素ごとに処理し，それらの結果をまとめてベクトルで返すようになっている，ということです。

sqrt(1:5)
1:5 * 2
1:5 * 6:10
1:10 > 5

• ?Vectorize

サーチパス

サーチパス(search path)とは，特定のシンボル（変数名）が与えられたときに，オブジェクトを探し出す場所の系列です。この「場所」とは，通常は環境です。 R はシンボルを評価するときにサーチパスに登録されている場所を探し，どこにも見つからなければ「オブジェクト "～" は存在しません」 というエラーを出します。 このサーチパスは，R を使用している間に動的に変化します。

search()  # 現在のサーチパスを表示

library() 関数を使ってパッケージをロードした場合，そのパッケージの環境がサーチパスに登録されます。 これによって，パッケージ内の関数や変数が単純な記法で使えるようになります。

library(nlme)
search()

attach() 関数を使うと，リストやデータフレームをサーチパスに登録できます。 登録すると，要素名を変数名のように使うことができます。 サーチパス上の登録される位置はグローバル環境の直後です。

iris$Sepal.Length  # attach()していないとこう書く必要がある
attach(iris)
Sepal.Length    # これでOK

attach() や library() を使ったときには，サーチパス上の登録される位置は，デフォルトではグローバル環境の直後になります。 この位置は引数を指定することで変更できますが，通常はデフォルトの位置が使い勝手が良いはずです。

detach() を用いて，attach() されたデータフレームなどをサーチパスから外すことができます。 この関数は library() でロードされたパッケージをサーチパスから外すこともできます。

search()
detach(iris)
search()

レキシカルスコープ

関数を呼び出すときには毎回，関数の内容を評価する場所としての新しい環境が作られます。 関数の中のローカル変数（引数も含みます）は，この新しい評価用環境に追加されていきます。

関数が作成される際( function( args ) body を評価する際)，クロージャに関数定義を行った環境が結びつけられますが， 関数呼び出し時に作成される新しい評価用環境の親としてセットされるのが，このクロージャが含む環境です。 これによって，関数を定義しようとした時に「そこにあった」関数の外の変数に，関数内部からいつでも（関数をどこかへ移しても）アクセスすることが可能になります。

一方で，関数評価の際にシンボルを解決しようとしてたどる環境の系列（サーチパスを最後に含む）と，関数呼び出しの連鎖によってできる構造（コールスタック call stack ）にもとづく環境の系列は， 異なってくる場合があり，そのせいで自分の作った関数が直観に反する動作をするかもしれません。

print.search <- function(env) {
  print(env)
  cat("\n")
  if (!identical(env, emptyenv()))
    Recall(parent.env(env))
}

print.stack <- function() {
  i = 1
  repeat {
    env <- parent.frame(i)
    print(env)
    cat("\n")
    if (identical(env, globalenv()))
      break
    i <- i + 1
  }
}

f1 <- function() {
  # a <- 2
  function(x) {
    # print.stack()
    # cat("- - - - - - - - - -\n")
    # print.search(environment())
    a * x
  }
}
f2 <- f1()
f3 <- function(x) {
  a <- 3
  f2(x)
}
a <- 4
f3(5)

存在する変数への代入

<<- （逆方向 ->> も可）という演算子は，通常の代入 <- と似ていますが，以下の点で異なる振る舞いをします:

1. エンクロージャをたどり，その名前ですでに存在する変数を探します。現在の環境は探しません。
2. 見つかった場合，その変数の値を書き換えます。もしパッケージの環境内で見つかった場合，ロックされているためにエラーが出るかもしれません。
3. 見つからなかった場合，グローバル環境にその名前の変数を作成し，値を入れます。

このような振る舞いをすることから，<<- を用いる場合は，環境とエンクロージャについて理解していなければ困惑してしまう可能性があります。

demo(scoping)

名前空間

各パッケージはロード時にそのパッケージ用の環境を持ちますが，さらに，パッケージには名前空間 (namespace) を持たせることができます。CRAN で公開されているパッケージのほとんどは名前空間を持っています。 名前空間を持っているパッケージでは，サーチの順序が通常と異なります。 パッケージ内の関数がローカルにない変数を参照しようとしたとき，まずその名前空間内のオブジェクトを探します。 次に，パッケージ同士でインポート関係がある場合，インポートしているパッケージの中を探します。 次に，base パッケージの名前空間の中を探します。 その後，グローバル環境から始まる通常のサーチパスを探します。

package::name という表記を用いることで，特定のパッケージ名を指定してそれがエクスポートしているオブジェクトにアクセスできます。 これを用いれば，例えばグローバル環境に同じ名前のオブジェクトがあったとしても，それを避けて，パッケージ内のオブジェクトを操作することができます。 もしパッケージが名前空間を持っているなら，library() でサーチパスに登録されていなくても，この表記でパッケージ内のオブジェクトにアクセスできます。 また，パッケージが名前空間を持っていない場合でも，ロードされサーチパスに登録されている状態ならば，この表記でパッケージを特定してアクセスできます。

package:::name という表記もあります。こちらは，エクスポートされているオブジェクトだけではなく，パッケージ内の内部オブジェクトにアクセスしようとます。 このようなアクセスはおそらくパッケージの開発者の意図から外れているでしょうから，特別な理由がない限り，使用するのは非推奨とされています。

S3クラス

S3クラスの実体は，オブジェクトの class 属性です。 class 属性の値はクラスの名前を表す文字列です。 値には文字列ベクトルも指定でき，これによって１つのオブジェクトが複数のクラスに所属していることを表します。 OOPの特徴の１つである「継承」もこれによって実現します。

class 属性もただの属性なので，自分で簡単に変更できます。

(x1 <- gl(3, 3, labels=c("A", "B", "C")))
class(x1)
(x2 <- unclass(x1))  # class属性を消去. class(x1) <- NULL でも消去可.
is.numeric(x2)

class(x2) <- "factor"  # 復活
x2

class 属性がセットされていない場合は，モードが暗黙のクラスとして代用されます。

総称的関数

R の関数のいくつかは総称的関数(generic functions)です。 総称的関数は，引数に渡されたオブジェクトのクラスに応じて， それに適した具体的処理をする関数へ引数を受け渡します。 例えば， print() 関数， summary() 関数， plot() 関数などが総称的関数です。 総称的関数は，関数の中身（ソース）を見たときに UseMethod() 関数を使っています。 これが S3 クラスにおいて「多態性」を実現する手段です。

methods() 関数を使うと，特定の総称的関数が利用可能なメソッド（クラス個別の関数）を一覧できます。

methods(print)

一覧で * の付いていない関数はそのフルネームによって参照できます。

print.anova

一覧で * の付いている関数は名前空間によって隠されているので，それを参照するには getS3method() 関数を使用する必要があります。

getS3method("print", "aov")

S4クラス

S3クラスとは異なり，S4 クラスは専用の関数で定義され，メソッドの定義やプロパティへのアクセスも専用の方法をとります。 ここでの詳細な解説は省きますが，次のドキュメントを参照してください。

• S4 クラスとメソッド入門
• Going from S3 to S4 object oriented programming in [R]
• How S4 Methods Work

R には S4 クラスで実装された stats4 パッケージが標準添付されています。 今後も主要な解析関数が S4 化されていく予定のようです。

help(package=stats4)
require(stats4)
example(mle)

ベクトル

R の最も基本的なデータ構造としてベクトル(vector)があります。 単純な数値や文字列であっても，ベクトルです。 R には純粋なスカラーはなく，長さ1のベクトルとして表現されています。

メモリの許すかぎり任意の長さの，いろいろな型のベクトルを扱えますが，１つのベクトルの要素はすべて同じ型でなければなりません。

ベクトルを作るにはいろいろな仕方があります。簡便でよく使われる方法として c() 関数があります。

x <- c(2, 3, 4, 5)
x

上の例のような整数のシーケンスのベクトルを作る場合は，: (コロン)を使った簡便な記法があります。

x <- 2:5
x

c() 関数は実はベクトルやリストを結合する関数です。 上の例では長さ1のベクトル同士を4つ結合していますが，もっと長いベクトルも結合できます。

x <- 1:40
y <- 100:90
(z <- c(x, y))

ベクトルの長さを得るには length() 関数を使います。

length(z)

行列

統計学で重要な位置を占めるのが行列(matrix)です。 行列を作るには matrix() 関数を使います。 matrix() 関数の第一引数にはベクトルを渡し，第２引数以降で行数や列数などを指定します。

(m1 <- matrix(1:6, nrow=3))
(m2 <- matrix(1:6, nrow=2))
(m3 <- matrix(1:6, nrow=2, byrow=TRUE))

byrow 引数に TRUE を指定することで，行列の値が行方向（横方向）に埋められていきます（デフォルトでは列方向）。

R では，行列も内部ではベクトルで表現されており，次元(dimensions)という属性をもつベクトルと考えられます。 よって，次元属性だけ変更することで，行列の形を変えることができます。

(m1 <- matrix(1:6, nrow=3))
dim(m1)             # 現在の次元情報
dim(m1) <- c(2, 3)  # 次元属性を変更
m1

配列

R における配列(array)とは，二元 two-way である行列を多元 multi-way に拡張したものです。 次元属性を操作することで，任意のn次元配列を作ることができます。 配列を作る array() 関数があります。

(a <- array(1:12, c(3, 2, 2)))
dim(a)

リスト

リスト(list)は，ベクトルと並んで， R において重要なデータ構造です。 統計データを保管する構造としてだけでなく，関数呼び出しなどの R の様々な側面がリストに依拠しています。 R は LISP や Scheme のような関数型言語としても使うことができ，言語がリストを基盤にしている点についてこれらから大きな影響を受けていると思われます。

リストとは，異なる型を要素にできるベクトル，と考えると簡単です。リストを作るには list() 関数です。

(x <- list(3.2, "apple", TRUE))                 # 数値，文字列，論理値を１つのリストに
(y <- list(price=3.2, fruit="apple", red=TRUE)) # 名前つきリスト

リストは，ベクトルと違って，何でも要素にできます。 ベクトルや行列はもちろんのこと，リスト自体もリストの要素にできます。 非常に強力な表現力を持ったデータ構造だということが推し測られます。

データフレーム

データフレーム(data frame) は， R での標準的統計データ構造です。 これは，他の統計ソフト (SAS や SPSS など) の cases × variables データ構造に対応するものです。

そうすると行列でいいように思えるかもしれませんが，データフレームが行列では困ります。 複数の種類の（すなわち複数の型の）変数を格納する必要性にしばしば見舞われるからです。

従って， R のデータフレームは（ベクトルではなく）リストの一種です。 ただし，リストの各要素が同じ長さのベクトルでなければならないという制約が付いています。 これによって，行列のように整って見えます。

データフレームを作るには， data.frame() 関数を使います。

mydata <- data.frame(Year=2002:2006, CPR=c(10, 8, 8, 4, 6), Tire=c(rep("Michelin", 4), "BS"))
mydata

データフレームは名前つきリストで，リストの各要素の名前をいわゆる統計学的な「変数」の名前として扱います。

ファクター

少々特殊ですが，覚えおくべきデータの種類として，ファクター(factor)があります。 これはいわゆる分散分析で言うところ「要因」，すなわち名義変数（カテゴリカルな変数）を表すためのものです。 順序変数を表す順序つきファクター(ordered factor)もあります。

ファクターも内部ではベクトルで表現されていますが，水準(levels)という属性が設定されており， この水準名が値と見なされます。水準名は内部表現の数値と一対一で対応しています。

ファクターを作るにはfactor()関数を使います。

x <- factor(c("apple", "banana", "banana", "orange", "apple", "orange"))
x
y <- factor(c(1, 2, 1, 1, 2, 1, 2))
y      # 1, 2 は数値ではなく水準名
y * 2  # 計算不可能なので NA が返る

levels() 関数で，水準名の一覧を得ることができます。 また， as.numeric() 関数などで数値に変換すると内部で使われている整数値が得られます。 これは作図の場面などで有益ですので覚えておきましょう。

x <- factor(c("apple", "banana", "banana", "orange", "apple", "orange"))
x
levels(x)
as.numeric(x)

gl() 関数で簡便にファクターを作成することもできます。

gl(2, 4, label = c("Control", "Treatment"))  # 水準数 2，１つの水準の反復数 4

時系列

時系列データを保持するために専用の時系列オブジェクトがあります。

ts(1:21, frequency=12, start=c(2007, 5))

モデル式

モデル式(formula)は R (そして S) の大きな特徴です。 R ではモデル式で統計モデルを表現します。 モデル式もオブジェクトであり，通常は ~ 演算子を使って生成します。

y ~ x1 + x2   # モデル式オブジェクトを返す

モデル式は，線型モデルなどのフィッティング関数やグラフィックスで主に利用されます。 モデル式の中では様々な演算子は通常と異なる意味を持ちます。 詳しくは統計モデルの節を参照して下さい。

種類のチェックと変換

原子型のベクトルからより複雑なデータ構造まで，あるオブジェクトが特定の種類のオブジェクトかどうかの確認や， 特定の種類のオブジェクトへ強制変換をするための関数があります。

多くの種類（行列とか論理値とか）には is.～() 関数(～は種類名)が用意されていて， この関数にオブジェクトを渡すことでその種類であるかどうかを確かめられます。

また， as.～() 関数(～は種類名)も用意されおり， この関数にオブジェクトを渡すことでその特定の種類に変換できます（もちろん渡すオブジェクトの種類によっては変換不可能な場合もあります）。

mydat <- data.frame(Year=2002:2006, CPR=c(10, 8, 8, 4, 6))
is.data.frame(mydat)
is.list(mydat)        # これも TRUE
is.matrix(mydat)      # これは FALSE
(mymat <- as.matrix(mydat))
is.matrix(mymat)      # TRUE に
is.numeric(mymat)
mymat2 <- as.character(mymat) # 属性は変換によって消える
dim(mymat2) <- c(5, 2)        # 次元属性を復活
mymat2
is.character(mymat2)

また，str()関数がオブジェクトを短い文字列で要約したものを返してくれるので， これを種類の識別に利用することもできます。

mydat <- data.frame(Year=2002:2006, CPR=c(10, 8, 8, 4, 6))
str(mydat)
str(as.matrix(mydat))

S4オブジェクト

S4クラスに属するオブジェクトは，他の一般的なオブジェクトとは異なるデータ構造を有しています。 オブジェクトが持つ情報を得たり変更したりするには， S4オブジェクトにアクセスする専用の関数や専用のインデクス記号を使わなければなりません。

添え字

ベクトル，行列，リストなどは，添え字指定(indexing)によってその要素を非常に柔軟に操作できます。 R では添え字は1から始まります。

まず基本として，添え字には数値ベクトルを渡すことができます。

(x <- 4:10)
x[3]           # 3番目だけ
x[1:4]         # 1～4番目
x[c(2, 3, 5)]  # 2, 3, 5番目
x[-4]          # 4番目以外
x[-4:-2]       # 2～4番目以外
x[2] <- 0      # 2番目を 0 に変更
x
x[5:7] <- NA   # 5～7番目を NA に
x
x[]            # xと同じ. ただし重要でない属性が消されたものが返る

添え字には論理値ベクトルも渡すことができます。その場合， TRUE が指定された要素だけが取りだされます。

(x <- 4:10)
x[c(T, T, F, F, T, F, T)]   # 1, 2, 5, 7番目だけ
x[x >= 8]                   # 8以上の値をもつものだけ

要素に名前が付いている場合，名前の文字列でも要素を取り出せます。

x <- 4:7
names(x) <- c("赤", "緑", "青", "黄")
x
x["緑"]

行列やデータフレームは二次元，配列には多次元の添え字が使えます。

(x <- matrix(1:12, nrow=3))
x[2, 3]       # 2行3列目の要素
x[2,]         # 2行目だけ
x[,3:4]       # 3,4列目だけ
x[-2,-1]      # 2行目と1列目以外
x[c(3,1,2),]  # ならべかえ
x[1,] <- 0    # 1行目をすべて 0 に
x
x[2, , drop=F]  # ベクトルにせず行列のままで取り出す

order()関数で，ベクトルの要素の順位を得ることができます。 これを利用してソート（昇順，降順並べ替え）をします。

(x <- matrix(c(5,3,2,7,2,5,4,3,1,6,3,6), nrow=4))
x[order(x[,1]),]                   # 1列目の順序でソート
x[order(x[,1], decreasing=TRUE),]  # 降順

リスト（データフレームも含む）には [ ] による添え字操作だけでなく，[[ ]] による添え字操作もよく用いられます。 [ ] と [[ ]] では意味が異なります。

[ ] による添え字操作では，取り出されるのは（部分的になった）リストです。 [[ ]] による操作では，リストの要素の中身（いろいろな種類がありえる）が取り出されます。

mydata <- data.frame(Year=2002:2006, CPR=c(10, 8, 8, 4, 6), Tire=c(rep("Michelin", 4), "BS"))
(x <- mydata[2])    # 2列目（リストの2番目）だけのデータフレームを取得
is.data.frame(x); is.vector(x)
(x <- mydata[[2]])  # 2列目の数値ベクトルを取得
is.data.frame(x); is.vector(x)

さらに，リストにおいては，名前が付いている要素には [[ ]] だけでなく $ を使った簡単な記述でもアクセスできます。

mydata <- data.frame(Year=2002:2006, CPR=c(10, 8, 8, 4, 6), Tire=c(rep("Michelin", 4), "BS"))
mydata$Year  # mydata[["Year"]] と同じ

• ?which
• ?which.min
• ?which.max
• ?max.col
• ?all
• ?any

サブセット

データセットを表すデータフレームからサブセットを取り出すには，上記の添え字を使うのもひとつの手ですが， サブセットを取り出すための専用の関数もあります。

mydata <- data.frame(Year=2002:2006, CPR=c(10, 8, 8, 4, 6), Tire=c(rep("Michelin", 4), "BS"))
subset(mydata, Tire == "Michelin" & CPR < 9) # mydata[mydata$Tire == "Michelin" & mydata$CPR < 9,] と同じ
subset(mydata, Year %in% 2004:2006, select=-2)  # 2列目以外

結合

複数のオブジェクトを結合して新しいオブジェクトを作ることもできます。 とくに，行列やデータフレームを延長する仕方で結合する方法が重要です。

c(1:3, 5:7)  # ベクトルの結合

m <- matrix(1:6, nrow=2)
cbind(m, c(10, 11))                  # 列を追加
cbind(m, c(10, 11), c(20, 21))       # 複数列
cbind(m, matrix(10, nrow=2, ncol=2)) # 行列でもよい
rbind(m, 10:12)                      # 行を追加
rbind(m, matrix(10, nrow=2, ncol=3))
rbind(m, m, m)

d <- data.frame(X=seq(10,25,len=4), Y=I(c("red","blue","green","yellow")))
d1 <- cbind( d, Z=gl(2,2,lab=c("A","B")) )  # 変数を追加
rbind(d1, list(100, "brown", "A"))   # ケースを追加
rbind(d1, list(100, "brown", "C"))   # これは警告
cbind(d, d)

d2 <- data.frame(AA=seq(0,by=0.1,len=5), Y=I(c("green","red","yellow","blue","black")))
merge(d1, d2)   # 共通する変数名でマージ
d3 <- data.frame(AA=seq(0,by=0.1,len=3), BB=I(c("green","blue","white")))
merge(d1, d3, by.x="Y", by.y="BB")  # 変数名を指定 
merge(d1, d3)   # 共通する変数がないと...

apply系関数

行列やリストに対して，すべての要素に同じ関数を繰り返し適用したい場合（そのようなことはよく起こるのですが）， ループで処理していたのでは実行速度が低速になるし，記述も煩雑になります。 そういう場合にapply系関数が役に立ちます。

apply()関数は，配列（行列を含む）の任意のマージン（行ごとや列ごと）に，指定の関数を適用し， その結果をまとめて返します。

(x <- matrix(1:12, nrow=3))
apply(x, 1, mean)  # 1 は行ごと
apply(x, 2, mean)  # 2 は列ごと

lapply()関数は，apply()関数のリスト版です。リストに対して，要素ごとに関数を適用します。

(x <- list(a=1:5, b=10, c=rep(4, 6)))
lapply(x, sqrt)

sapply()関数は，lapply()関数と同じくリストを対象にしますが， lapply()関数がリストを返すのに対し， sapply()関数は返すオブジェクトを可能なかぎり単純に（ベクトルや行列に）します。

( x <- list( a=1:6, b=rep(10,6), c=c(rep(4,3),rep(3,3)) ) )
sapply(x, mean)
sapply(x, function(x) x ^ 2)

mapply()関数は，sapply()関数の多変量版で，引数のリストやベクトルを複数とれます。 例えば，長さ4のベクトルを2つ渡したら，それぞれの要素を１つずつ引数として関数が適用され， 全部で関数は4回適用されることになります。

mapply(rep, 1:4, 6:3)

tapply()関数は，ファクターの水準ごとに関数を適用します。 水準別の基本統計量などを求めるのに便利です。

tapply(iris$Sepal.Length, iris$Species, mean)

replicate()関数は，sapply()関数に似ていますが， リストやベクトルを渡すのではなく，１つの数（回数）を指定します。 その回数だけ，第２引数に渡した表現式を評価します。これはシミュレーションなどに便利です。

replicate(100, mean(rnorm(20, m=50, s=10)))

apply()関数は汎用的ですが，行列の合計や平均を求めることはよくあるので， これらについてはさらに高速な専用の関数が用意されています。

(x <- matrix(1:12, nrow=3))
rowSums(x)
colSums(x)
rowMeans(x)
colMeans(x)

• ?by
• ?aggregate

条件分岐

条件分岐に使われるのは，他の言語と同様， if 文です。

if (表現式1) 表現式2 else 表現式3

表現式1の評価結果がTRUEの場合，続いて表現式2が評価されます。FALSEの場合は，表現式3が評価されます。 表現式1の評価結果が数値の場合は，論理値に変換して判断されます。 0 は FALSE，その他は TRUE です（ただし NA や NaN は許されません）。

"else 表現式3" は省くことができます。その場合，この構文が意味するのは，表現式2が評価されるかされないか，です。

x <- 4
if (x > 0) { print("Hello") } else { print("Bye") }

if文であっても，全体で表現式であるので，値を返します。 if文全体の値は，表現式2または表現式3のどちらか評価されたほうの表現式の値です。 もし else が省略され，かつ，表現式1がFALSEであった場合，if文の値はNULLです。

x <- 4
y <- if (x > 0) { x ^ 2 } else { 0 }
y

Rには，if文とは別に，ifelse() という関数も用意されています。

ifelse(表現式1, 表現式2, 表現式3)

これも同じく，表現式1のTRUE/FALSEに応じて，表現式2または表現式3が評価され， その値がifelse()関数の戻り値になります。

if文も値を返すにもかかわらず，どうしてこれが用意されているのかというと， ifelse()関数はベクトル化されているのです。 if文はベクトル化されておらず，表現式1にベクトルを渡してもその最初の要素だけが使われます。

x <- -4:4
y <- ifelse(x >= 0, x ^ 2, 0)
y
z <- if (x >= 0) x ^ 2 else 0
z

反復

反復，すなわち，表現式の繰り返し評価（ループ）によく使用されるのは，for文とwhile文です。 とくに for は，Rに特徴的なベクトルやリストをうまく扱えるようデザインされています。

for (変数名 in 表現式1) 表現式2

表現式1は，評価の結果，ベクトルまたはリストを返すものでなければなりません。 そのベクトルまたはリストの各要素が１つ目から順番に「変数名」に与えた名前の変数に代入され， その後，毎回，表現式2が評価されます。 よって，例えば，表現式1が長さ4のベクトルであれば，for文は4回ループし，表現式2は4回評価されることになります。

for (x in 1:10) {
  y <- sqrt(x)
  cat(x, "の正の平方根は", y, "\n")
}

while文では，for文のように反復回数が与えられるのではなく，条件が満たされるまで延々とループします。

while (表現式1) 表現式2

表現式1は条件判断であり，if文と同様，評価結果を論理値として解釈できるものを指定します。 TRUEであれば，ループが継続し，表現式2が評価され，その後また条件判断に戻ってきます。 FALSEであれば，その時点でループは終了し，whileの次の文へ移行します。

x <- 5
while (x > 0) {
  x <- x - 1
  print(x)
}

forやwhileの表現式2の中では，breakとnextという２つの特殊な文が使えます。 breakが評価されると，ループを中断して（forやwhileの）次の文へ移ります。 nextが評価されると，現在の回の評価を中断して，ループの次の回に強制的に移ります。

x <- 5
while (x > 0) {
  x <- x - 1
  if (x == 2) break
  print(x)
}
x <- 5
while (x > 0) {
  x <- x - 1
  if (x == 2) next
  print(x)
}

ループさせる方法を紹介しましたが，基本的にRのプログラミングではこのようなループ構文の使用はできるかぎり避け，同じことをする高速な関数を利用します。 ループは，どうしてもそれを使わなければ目的の処理が記述できない場合にのみ使いましょう。

この他にもrepeatやswitchといった構文があります。

点と線の種類

グラフィックスパラメータのうち pch はプロットする際の点（マーク）の種類， lty は折れ線グラフなどで線を描く際の線の種類を指定するものです。

プロットの点の種類の指定や線の種類の指定はよく使うと思われるので，種類を一覧できるスクリプトを下に用意しました。

local({
	pch_mat <- matrix(0:127, ncol=16, byrow=TRUE)
	plot.new()
	plot.window(xlim=c(0.5,ncol(pch_mat)), ylim=c(nrow(pch_mat), 0.5))
	for (y in 1:nrow(pch_mat)) {
		for (x in 1:ncol(pch_mat)) {
			points(x, y, pch=pch_mat[y,x], cex=2.5)
			text(x-0.35, y-0.35, pch_mat[y,x], cex=0.5)
		}
	}
	title("pch")
})

pch には文字か数値を指定できます。文字を指定した場合はその文字が座標上の点を表すマークとして使われます。 ２文字以上の文字列を指定したなら，使われるのは最初の１文字だけです。

pch に数値を指定した場合は，0 ～ 25 の数値はプロット用のマーク（○とか△とか）を指定する番号として扱われます。 32 以上の数値は文字コードとして扱われ，対応する文字がマークに使われます。 26 ～ 31 の数値は現在のバージョンでは使用できないようです。

local({
	lty_list <- c(list("blank", "solid", "dashed", "dotted", "dotdash", "longdash", "twodash"),
		0:15, c("11", "12", "18", "1F", "FF", "1814", "2224282C"))
	plot.new()
	plot.window(xlim=c(0,1), ylim=c(1, length(lty_list)))
	for (y in 1:length(lty_list)) {
		segments(0, y, 1, y, lty=lty_list[[y]])
		mtext(ifelse(is.character(lty_list[[y]]), paste('"', lty_list[[y]], '"', sep=""),
			lty_list[[y]]), 2, at=y, las=1, cex=0.7)
	}
	title("lty")
})

lty には数値か文字列を指定します。 線の種類を表す文字列が定められており，上のスクリプトによる一覧にある下方の 7 種類です。

lty に数値を指定する場合，通常，使用するのは 0 ～ 6 です。 上のスクリプトによる一覧でわかるように，0 は線を描かないという指定になり，1 ～ 6 は線の各種類を表す番号です。 それぞれ上の文字列値と対応します。 7 以上の数値 n を指定した場合，n %% 6 と同じ種類を指定したことになるようです。

また，lty は上述の 6 種類だけでなく，いろいろな種類の破線を指定できるようにもなっています。 これを用いる場合，1 ～ 9 と A, B, C, D, E, F (16進数を表す) の文字を，偶数個（ただし 2～8 文字）並べた文字列を指定します。 最初の文字から順番に，線の長さと空白の長さを表すことになります。

mfrow, mfcol

グラフィックスパラメータの mfrow または mfcol を設定することで， 作図領域を m×n の格子状に分割できます。 分割の設定がされた状態で作図関数を繰り返し実行すると，セルが順番に埋まっていきます。

oldpar <- par(mfrow=c(2, 2))  # 2 x 2 に分割する
example(plot)  # 4枚のグラフを描画
par(oldpar)

mfrow と mfcol の違いは，埋まっていく方向が行方向か列方向かの違いです。

次のスクリプトを実行すると，分割された状態で各領域の占める範囲が理解できます。

op <- par(mfrow=c(2,2), oma=rep(3,4), mar=rep(3,4))
for (i in 1:4) {
  plot.new()
  plot.window(xlim=c(-1,1), ylim=c(-1,1))
  box("plot", lty="dotted")
  box("figure", lty="dotted")
  text(0, 0, "プロット領域")
  mtext(paste("内部マージン",1:4), 1:4, line=1)
  mtext(paste("作図領域", LETTERS[i]), 3, line=2, at=-1.1)
}
mtext(paste("外部マージン",1:4), 1:4, line=1, outer=TRUE)
mtext("デバイス領域", 3, line=2, outer=TRUE, at=0)
par(op)

layout

layout()関数を使うことでも，作図領域を分割できます。 違いは，layout()関数ではより柔軟な割り当てができるという点です。

layout()関数には，領域の割り当て方を示す引数として行列を渡します。 この行列の値は，個々の領域の範囲を指定するのに加えて，描画の順番にもかかわります。

(m <- matrix(c(1,2,3,2), nrow=2))  # 領域を３つに分割. 下段は２列で１つ
layout(m)
example(barplot)   # この例は９つの図を描くので，３ページ

split.screen

split.screen()関数は，layout()関数と同様，領域を分割するのですが， mfrow と mfcol や layout() のように， 作図関数を繰り返し呼び出せば分割された領域が埋まっていくというタイプではありません。 split.screen()関数によって分割された領域（これを便宜的にスクリーンと呼びます）には番号が振られます。 また，「現在のスクリーン」という情報が記録されており，番号指定して現在のスクリーンを切り替えます。 作図関数による描画は現在のスクリーンに対してしか行えません。

split.screen()関数による分割は，mfrow，mfcolと同様に，格子状です。 しかし，split.screen()関数は，分割してできたスクリーンをさらに分割するということができ， これによってlayout()関数のような柔軟な分割も可能になります。

split.screen(c(1,2)) # 1行2列に分割
split.screen(c(2,1), screen=1) # さらに左側を2行1列に分割
screen(3)
curve(x^3-3*x, -2, 2)
screen(4)
qqnorm(precip)
screen(2)
dotchart(VADeaths)

グリッドグラフィックス

グリッドグラフィックス(grid graphics)は トレリスグラフィックス(trellis graphics)とかラティスグラフィックス(lattice graphics)とも呼ばれます。 どれも「格子」という意味です。 グリッドグラフィックスは，上述の領域分割して複数の図をまとめる場合のように， 格子を描き，その中に個々のグラフを描くものです。 主に，１つのデータセットを条件ごとに層分けして，それぞれについて同じ種類のグラフを描くという場合に用いられます。

グリッドグラフィックスの利用はR標準のグラフィックスと手順が少々異なるため，注意が必要です。 詳しくは他のドキュメントやメーリングリストのアーカイブを参照してください。

require(lattice)
old.prompt <- grid::grid.prompt(TRUE)
example(xyplot)
grid::grid.prompt(old.prompt)

3Dグラフィックス

rglパッケージを入れることで，OpenGLによる3Dグラフィックスが利用可能です。 この3Dグラフィックスのデバイスは，対話的な操作を可能にします。 出版用にはあまり利点がないかもしれませんが， インタラクティブであることが高次元データの把握を非常に促進すると思われるので， 集めたデータの特徴を探索的に調べる場面や口頭でのプレゼンテーションにおいて ぜひ活用することをお勧めします。

require(rgl)
plot3d(airquality[1:3], size=5)
example(surface3d)

動的ロード

dyn.load() と dyn.unload() を用いて，DLLのロード/アンロードを行うことができます。 これによって，自分の必要とする外部ルーチンの入った任意の DLL を R のプロセスに動的にロードし，使用することができます。 ロード済みの DLL の一覧は getLoadedDLLs() で得ることができます。

dyn.load("sample.dll")
getLoadedDLLs()
dyn.unload("sample.dll")
getLoadedDLLs()

外部ルーチンを使うには，R がそのエントリーポイントを知らなければなりません。DLLがエントリーポイントを R に登録する方法は2種類あります。 1つはOSの標準的DLLローディングを用いる方法，もう1つは R が備えるプラットフォーム独立な登録手続きの使用です。 前者は，関数をエクスポートするだけで利用できます。後者では，用意されている登録用の関数をDLL内で呼ぶよう実装が必要です。 後者の方法を用いるなら，関数をエクスポートする必要はありません。

後者を用いて明示的に登録されたルーチンのみ getDLLRegisteredRoutines() で一覧することができます。 また，is.loaded() で，個別のルーチン名を指定して，登録済みかどうかをチェックできます。こちらは前者のルーチンでも使用可能です。

getNativeSymbolInfo() を用いると，登録された各外部ルーチンの情報を得ることができます。これも，登録方法に関係なく利用できます。

is.loaded("my_inner_product")

getNativeSymbolInfo("my_inner_product")
getNativeSymbolInfo("dqrls")

# C ソース
# http://x-n.io/doc/r-intro-lecture/sample.c
# これを R CMD SHLIB でビルドしたもの
# http://x-n.io/doc/r-intro-lecture/sample.dll

browser()

my.func1 <- function(x, y) {
    for (i in 1:5) {
        x <- x + i
        browser()
        y <- y / i
    }
    print(x)
    print(y)
}
my.func1(2, 3)

コードの実行途中で browser() 関数を呼び出すと，その箇所で実行を一時停止させることができます。 停止している状態でコンソール入力が可能ですので，変数の内容を調べたり書き換えたり，何か関数を呼び出したりすることもできます。

browser() 関数で一時停止している間は，いくつか特別な命令が使用できます。

browser()中にリターンキーだけ入力すると c 命令と同じ意味になります。

debug()

debug() 関数は，browser() 関数と似ています。debug() 関数の引数として他の関数を渡すと， その関数に「デバッグ」マークが付き，以後，その関数が呼び出されるたびに，関数内容を実行する寸前の段階でbrowser()のように一時停止します。 一時停止中に行える操作はbrowser()関数の場合と同様ですが，リターンキーの動作が n 命令と同じになっています。

undebug() 関数で，「デバッグ」マークを取り除き，もとの状態（関数を呼び出しても一時停止しない）に戻せます。

my.func1 <- function(x, y) {
    for (i in 1:5) {
        x <- x + i
        y <- y / i
    }
    print(x)
    print(y)
}
debug(my.func1)
my.func1(3, 4)

undebug(my.func1)
my.func1(3, 4)

trace()

trace() 関数の引数としてある関数を渡すと，その関数の呼び出しが監視されます。デフォルトでは，関数呼び出しのたびに，その実引数の表現式とともに，呼び出された旨がプリントされます。

監視対象の関数以外に，関数や表現式を trace() 関数の引数として渡すことで，監視対象の関数の呼び出し直前，呼び出し直後などにその関数/表現式を評価するようセットすることもできます。

監視中の関数に対して untrace() 関数を用いれば，監視状態を解除できます。また，tracingState() 関数で監視機能を全体的にON/OFFできます。

trace(sum)
boxplot(rnorm(100))

untrace(sum)
boxplot(rnorm(100))

traceback()

実行中にエラーが起こった場合に，traceback() 関数を呼び出すと，最後にエラーが起こったときのコールスタックのようなもの（エラーに至るまでの関数呼び出しの系列）を表示してくれます。

my.func1 <- function(x) {
  cat("my.func1 ", x, "\n")
  my.func2(x)
}
my.func2 <- function(x) {
  cat("my.func1 ", x ^ 2, "\n")
  x ^ 2 + no.such.a.variable
}
my.func1(5)
traceback()

recover()

recover() 関数を呼び出すと，そこに至るまでの関数呼び出しのリストを表示し，選択待ちの状態になります。 ユーザは，リストのうちの特定のものを選んでその環境で browser() を実行するか，または browser() を実行せずに先に進むかを選択します。

下のような使い方ができます：

options(error = recover)

この設定によって，エラー発生時に自動的にその場で recover() が実行され，エラーの状況を細かく調べることができます。

もちろん自分で自作関数に recover() の呼び出しを入れておくこともできます。

インストール

講習会ではインストール済み PC の利用が前提なので省略します。情報が必要な場合は CRAN の"R Installation and Administration"， RjpWikiの「Rのインストール」の項を参照してください。

大学の研究室などで使用する場合は，CRAN など外部への接続のためにhttpプロキシの設定が必要である点に注意してください。 プロキシサーバを Sys.setenv() で指定するよりも，インストーラ実行時にカスタマイズを選んで --internet2 オプションを付加するのが楽です。

日本語設定

講習会では日本語使用設定の済んでいるPCの利用が前提なので省略します。 情報が必要な場合は RjpWiki の「Rのインストール」の項を参照してください。

ユーザ個人用設定

R_USER という名前の(Windowsの)環境変数をセットすることで， ユーザのホームディレクトリを明示的に設定できます。 （これがセットされていない場合， R は他の方法でユーザのホームディレクトリを決めます。）

この機能は，主に以下の３つの設定ファイルを使うときに利用します。 R_USER にパスをセットしたディレクトリが，以下の設定ファイルを置く場所になります。

ウィンドウ(Rgui)

Rgui.exe はRのGUIフロントエンドで，皆がよく使う方法です。 スタートメニューにはこれへのショートカットが置かれています。

Rgui のメイン機能はコンソールウィンドウです。 ユーザはここに文字を打ち，同じくここに結果が表示されます。 他にも，グラフィックスウィンドウやスクリプトエディタ，データ編集ウィンドウなどを持ちます。

Rguiは，インターフェイスの種類として MDI と SDI を選択できます。 現バージョンのデフォルトは MDI ですが， 著者としては SDI がお勧めです。 MDI/SDI の切り替えは，Rconsole で設定できますし，起動オプションでも変更できます。 Rgui の起動後に変更することはできません。

コマンドシェル(Rterm)

Rterm.exe は Windows のコマンドシェル（コマンドプロンプト）上で動くフロントエンド・プログラムです。 これは Linux のシェルでの R の利用方法に似ています。

Rterm の利用においては，コマンドプロンプトのウィンドウが Rgui でのコンソールウィンドウの代わりをするわけですが， その他のウィンドウが利用不可能なのではなく， Rgui と同様に，スクリプトエディタやグラフィックウィンドウなど， 上で紹介したすべてのウィンドウが利用可能です。 また，履歴などの機能も Rgui と同等です。 GUI のメニューがない点くらいしか大きな違いはないかもしれません。 もちろん， Rconsole のフォント指定などは反映されず，コマンドプロンプトの設定のままです。

コマンドプロンプト上で標準入出力を利用して動作するので， コマンドプロンプトの持つリダイレクト機能が Rterm に対しても利用できます。 リダイレクトで入力を与えた場合は，指定の入力に対する処理を終え次第 Rterm が終了します。 その場合のデフォルトのグラフィックデバイスは postscript になります。

バッチ実行(Rcmd BATCH)

Rterm にリダイレクトしてもバッチ処理ができますが，バッチ処理用のコマンドも用意されています。 (内部では Rterm が使われています。)

Rcmd BATCH [--options] inputfile [outputfile]

outputfile を省略した場合，出力は，(入力ファイル名).Rout というファイルに書き出されます。 もし入力ファイルが .R という拡張子だったら，その場合に限り拡張子が取り除かれます。

Rcmd には他にも，コンパイルやアドオンの更新など，いろいろなことをするコマンドが用意されています。 詳細は次のコマンドで参照してください。

Rcmd --help

バッチ実行(Rscript)

バッチ実行には，Rscript.exe を使うこともできます。

Rscript [--options] [-e expr] inputfile [args]

Rscript には出力ファイルを指定するオプションがありませんが，出力のリダイレクトで代用できます。

Windows 版の Rcmd BATCH ではスクリプトへ引数を渡す機能がうまく使えませんが， Rscript ではちゃんと引数を渡すことができます。

Rscript は直接に表現式を書ける -e オプションが利用でき（このオプションは Rterm の機能），かなり便利です。

Rscript -e "commandArgs(); proc.time()" arg1 arg2 arg3

COM

R-(D)COM を合わせてインストールすることで， COM インターフェイスを介してRを利用できます。 R-(D)COM には COM インターフェイスの利用例として RExcel (Microsoft Excel のアドイン) が付属しています。 WSH や HTA などから R をインタラクティブに利用することもできるでしょう。

R 本体には DDE サーバは実装されていません。 どうしても DDE を使いたければ， SciViews の svIDE::guiDDEInstall() が利用できるかもしれませんが， お勧めはしません。

その他

他にもいくつかのメジャープログラミング言語や既存ソフトウェアに向けたバインディングが開発されています。CRAN をご覧ください。