数学 - R入門

目次

絶対値を求める

abs関数を使う。引数には数値型ベクトルを与える。

> abs(10)
[1] 10
> abs(-20)
[1] 20
> abs(3.3) - abs(-3.3)
[1] 0
> abs(c(100, -200))
[1] 100 200

平方根を求める

sqrt関数を使う。

> sqrt(2)
[1] 1.414214
> sqrt(3)
[1] 1.732051
> sqrt(4)
[1] 2
> sqrt(0)
[1] 0
> sqrt(1 / 2)
[1] 0.7071068
> sqrt(-2)
[1] NaN
 警告メッセージ: 
 sqrt(-2) で:   計算結果が NaN になりました

等差数列を求める

seqコマンドを使う。引数は1～3つ与えることができ、それぞれ以下のようになる。最後の例のとおり、最後に公差を加えて末項に一致しない場合は、その1つ前の項までが作成される。

• seq(初項)
• seq(初項, 末項) ※公差は1
• seq(初項, 末項, 公差) ※末項に届かないときはその1つ前の項まで

> seq(3)
[1] 1 2 3
> seq(2, 5)
[1] 2 3 4 5
> seq(3, 12, 4)
[1]  3  7 11

負数や実数の指定も可能。

> seq(-1, -11, -2)
[1]  -1  -3  -5  -7  -9 -11
> seq(1.2, 2.8, 0.4)
[1] 1.2 1.6 2.0 2.4 2.8

順列を求める

Rには標準では順列の総数を求める関数は搭載されていない。階乗を使った式で表すことができるため、階乗を求めるfactorial関数を使用して、順列の総数を求める関数permuを自作する。

> permu <- function(n, r) {factorial(n) / factorial(n - r)}

₅ P ₂ (=20)、 ₅ P ₃ (=60)を求めてみる。

> permu(5, 2)
[1] 20
> permu(5, 3)
[1] 60

なおn > r、0!=1である。n=rの場合は、階乗そのものの計算になる。

組合せの数を求める

choose関数を使う。n個からr個とった組合せの総数を求める。

₅ C ₂ (=10)、 ₇ C ₃ (=35)、 ₁₀ C ₂ (=45)を求めてみる。

> choose(5, 2)
[1] 10
> choose(7, 3)
[1] 35
> choose(10, 2)
[1] 45

三角関数の値を求める

cos関数（余弦関数）、sin関数（正弦関数）、tan関数（正接関数）を使う。角θの値が、次の各値の時、cosθ、sinθ、tanθを求めてみる。

θ=0, π/2, π, 2π

> theta <- c(0, pi / 2, pi, 2 * pi)
> cos(theta)
[1]  1.000000e+00  6.123032e-17 -1.000000e+00  1.000000e+00
> sin(theta)
[1]  0.000000e+00  1.000000e+00  1.224606e-16 -2.449213e-16
> tan(theta)
[1]  0.000000e+00  1.633124e+16 -1.224647e-16 -2.449294e-16

～-17や～-16は計算上限りなく小さい値が求まった（≒0.0）ということであり、実際にそのような値が精度良く求まったということではない。～+16（≒∞）も同様である。

対数の値を求める

log関数を使う。aを底とするNの対数の求め方は以下のとおり。

log(N, a)

log ₃ 3(=1)、log ₅ 1(=0)、log ₃ 243(=5)の値をそれぞれ求める。

> log(3, 3)
[1] 1
> log(1, 5)
[1] 0
> log(243, 3)
[1] 5

底は省略することができる。その場合はeを底とする自然対数が求まる。

> log(2)
[1] 0.6931472
> log(2, exp(1))
[1] 0.6931472

常用対数（10を底とする対数）を求めるlog10関数、2を底とする対数を求めるlog2関数もある。

> log10(100)
[1] 2
> log(100, 10)
[1] 2
> log2(20)
[1] 4.321928
> log(20, 2)
[1] 4.321928

代数方程式の根を求める

polyroot関数を使う。以下は2x ³ +3x ² +8x-5=0の3つの根（0.5,-1+2i,-1-2i）を求めた例。虚部も求めることができる。引数には、次数の低いほうから係数をベクトルでまとめて与える（この場合はc(-5,8,3,2)となる）。

> polyroot(c(-5, 8, 3, 2))
[1]  0.5+0i -1.0+2i -1.0-2i

戻り値は複素数型。複素数型から実部だけを取り出すにはRe関数を、虚部だけを取り出すにはIm関数を使う。これら関数の戻り値はそれぞれ実数型。

> class(d)
[1] "complex"
> Re(d)
[1]  0.5 -1.0 -1.0
> Im(d)
[1]  3.372483e-16  2.000000e+00 -2.000000e+00
> class(Re(d))
[1] "numeric"
> class(Im(d))
[1] "numeric"

微分する

ある式を関数と見なして、その式（関数）の導関数を求める（微分する）ことができる。expression関数とD関数を併用する。

以下はxの4乗を微分した例。手計算では「xの4乗」を微分すれば、「4かけるxの3乗」になる。

> f <- expression(x ^ 4)
> D(f, "x")
4 * x^3

いろいろな関数も微分できる。例えばsin(3x-2)を微分する。手計算では微分をすると3cos(3x-2)になる。

> f <- expression(sin(3*x - 2))
> D(f, "x")
cos(3 * x - 2) * 3

式には定数を含めることもできる。

> f <- expression(a * x ^ 3)
> D(f, "x")
a * (3 * x^2)

定積分を求める

integrate関数を使う。引数は以下のとおり

integrate(関数, 積分の下端, 積分の上端)

関数はfunction関数で定義しておくこと。

以下は、x^2を0から1まで、0から2まで積分した例。手計算で定積分はそれぞれ1/3,8/3である。

> f <- function(x) x ^ 2
> integrate(f, 0, 1)
0.3333333 with absolute error < 3.7e-15
> integrate(f, 0, 2)
2.666667 with absolute error < 3e-14

三角関数などのように定義済みの関数はそのままでも使うことができる。既存の関数を使用して関数を定義することもできる。

> integrate(cos, 0, pi / 2)
1 with absolute error < 1.1e-14
> f <- function(x) cos(x)
> integrate(f, 0, pi / 2)
1 with absolute error < 1.1e-14

置換積分法が必要な積分も、簡単に行える。下記の例では、手計算で定積分は8/sqrt(2)=5.656854…である。

> f <- function(x) 4 * cos(x / 2)
> integrate(f, 0, pi / 2)
5.656854 with absolute error < 6.3e-14

二つの集合MとNの共通部分M∩Nと和集合M∪Nを得る

共通部分（どちらにも属している要素の集合）M∩Nを得るにはintersect関数を、和集合（少なくとも一方に属する要素の集合）M∪Nを得るにはunion関数を得る。以下、例。

> m <- seq(2, 18, by = 2)
> n <- seq(3, 18, by = 3)
> print(m)
[1]  2  4  6  8 10 12 14 16 18
> print(n)
[1]  3  6  9 12 15 18
> union(m, n)
 [1]  2  4  6  8 10 12 14 16 18  3  9 15
> intersect(m, n)
[1]  6 12 18

ベクトルの要素に対して行う処理のため、当然、要素が数値以外でもかまわない。

> s1 <- c("スーパークリーク", "メイショウドトウ", "サクラチヨノオー")
> s2 <- c("メイショウドトウ", "サクラチヨノオー", "メジロアルダン")
> union(s1, s2)
[1] "スーパークリーク" "メイショウドトウ" "サクラチヨノオー" "メジロアルダン"  
> intersect(s1, s2)
[1] "メイショウドトウ" "サクラチヨノオー"

ベクトルの要素について累積の和を求める

ベクトルの要素の値をインデックス順に足した累積の値を得るには、cumsum関数を使う。

> i <- 1:10
> i
 [1]  1  2  3  4  5  6  7  8  9 10
> cumsum(i)
 [1]  1  3  6 10 15 21 28 36 45 55

ベクトルの要素について累積の積を求める

ベクトルの要素の値をインデックス順に掛けた累積の値を得るには、cumprod関数を使う。順番に要素を掛けるだけのため、最後の例のように要素の値をすべて同じにすれば、単純に累乗が求まることになる。

> i <- 1:5
> i
[1] 1 2 3 4 5
> cumprod(i)
[1]   1   2   6  24 120
> i <- rep(2, 8)
> i
[1] 2 2 2 2 2 2 2 2
> cumprod(i)
[1]   2   4   8  16  32  64 128 256

逆双曲線関数の値を求める

asinh関数（逆双曲線正弦）、acosh関数（逆双曲線余弦）、atanh関数（逆双曲線正接）をそれぞれ使う。逆双曲線余弦（緑色）は定義域が x > 1、逆双曲線正接（青色）は定義域が -1 < x < 1 であることに注意。

> plot(0, 0, type = "n", xlim = c(-3, 3), ylim = c(-3, 3),
+  xaxs = "i", yaxs = "i", xlab = "x", ylab = "y")
> d <- seq(-3, 3, 0.001)
> lines(d, asinh(d), col = "red")
> d <- seq(1, 3, 0.001)
> lines(d, acosh(d), col = "green")
> d <- seq(-0.999, 0.999, 0.001)
> lines(d, atanh(d), col = "blue")
> abline(h = -3:3, v = -3:3, lty = "dotted")
> text(-2.9, 2.8, expression("y =" * sinh^-1 * "(x)"), adj = 0, col = "red")
> text(-2.9, 2.5, expression("y =" * cosh^-1 * "(x)"), adj = 0, col = "green")
> text(-2.9, 2.2, expression("y =" * tanh^-1 * "(x)"), adj = 0, col = "blue")

計算例は、以下のとおり。

> d <- seq(-0.8, 0.8, 0.4)
> for (i in 1:length(d)) cat(sprintf("asinh(%4.1f) = %f\n", d[i], asinh(d[i])))
asinh(-0.8) = -0.732668
asinh(-0.4) = -0.390035
asinh( 0.0) = 0.000000
asinh( 0.4) = 0.390035
asinh( 0.8) = 0.732668
> d <- 1:5
> for (i in 1:length(d)) cat(sprintf("acosh(%4.1f) = %f\n", d[i], acosh(d[i])))
acosh( 1.0) = 0.000000
acosh( 2.0) = 1.316958
acosh( 3.0) = 1.762747
acosh( 4.0) = 2.063437
acosh( 5.0) = 2.292432
> d <- seq(-0.8, 0.8, 0.4)
> for (i in 1:length(d)) cat(sprintf("atanh(%4.1f) = %f\n", d[i], atanh(d[i])))
atanh(-0.8) = -1.098612
atanh(-0.4) = -0.423649
atanh( 0.0) = 0.000000
atanh( 0.4) = 0.423649
atanh( 0.8) = 1.098612

複数の文字列による重複順列を得る

重複順列とは、複数のものから同じものを繰り返しとることを許してとって並べた順列のこと。高校で学ぶ数学で重複順列は「n個からr個とった重複順列」という。

以下では、与えれたn個の文字列からn個とった重複順列を求めている。例として"A"と"B"の2つの文字列であれば、"AA", "AB", "BA", "BB"の4個の文字列を作成するということ。"A", "B", "C"の3つであれば、"AAA", "AAB", "AAC", "ABA", …, "CCB", "CCC"の27個となる。

gtoolsパッケージのpermutations関数を使う。repeats.allowオプション（デフォルト：FALSE）がFALSEの場合は、繰り返し取ることが認められなくなり、順番を考慮した組合せになってしまうため、TRUEとすること。戻り値は配列のため、これをapply関数を利用してpaste0関数で連結すれば、ベクトルでまとめて得られる。

> library(gtools)
> ss <- c("A", "B")
> permutations(2, 2, ss)
     [,1] [,2]
[1,] "A"  "B" 
[2,] "B"  "A" 
> ar <- permutations(2, 2, ss)
> apply(ar, 1, function(s) {return(paste0(s, collapse = ""))})
[1] "AB" "BA"
> ss <- c("A", "B", "C")
> permutations(3, 3, ss)
     [,1] [,2] [,3]
[1,] "A"  "B"  "C" 
[2,] "A"  "C"  "B" 
[3,] "B"  "A"  "C" 
[4,] "B"  "C"  "A" 
[5,] "C"  "A"  "B" 
[6,] "C"  "B"  "A" 
> permutations(3, 3, ss, repeats.allow = TRUE)
      [,1] [,2] [,3]
 [1,] "A"  "A"  "A" 
 [2,] "A"  "A"  "B" 
 [3,] "A"  "A"  "C" 
 [4,] "A"  "B"  "A" 
 [5,] "A"  "B"  "B" 
 [6,] "A"  "B"  "C" 
 [7,] "A"  "C"  "A" 
 [8,] "A"  "C"  "B" 
 [9,] "A"  "C"  "C" 
[10,] "B"  "A"  "A" 
[11,] "B"  "A"  "B" 
[12,] "B"  "A"  "C" 
[13,] "B"  "B"  "A" 
[14,] "B"  "B"  "B" 
[15,] "B"  "B"  "C" 
[16,] "B"  "C"  "A" 
[17,] "B"  "C"  "B" 
[18,] "B"  "C"  "C" 
[19,] "C"  "A"  "A" 
[20,] "C"  "A"  "B" 
[21,] "C"  "A"  "C" 
[22,] "C"  "B"  "A" 
[23,] "C"  "B"  "B" 
[24,] "C"  "B"  "C" 
[25,] "C"  "C"  "A" 
[26,] "C"  "C"  "B" 
[27,] "C"  "C"  "C" 
> ar <- permutations(3, 3, ss, repeats.allow = TRUE)
> apply(ar, 1, function(s) {return(paste0(s, collapse = ""))})
 [1] "AAA" "AAB" "AAC" "ABA" "ABB" "ABC" "ACA" "ACB" "ACC" "BAA"
[11] "BAB" "BAC" "BBA" "BBB" "BBC" "BCA" "BCB" "BCC" "CAA" "CAB"
[21] "CAC" "CBA" "CBB" "CBC" "CCA" "CCB" "CCC"

複数の文字列による重複組合せを作成する

重複組合せとは、複数のものから同じものを繰り返しとることを許してとった組合せのこと。例えば、aとbから3個とる重複組合せは、aaa, aab, abb, bbbの4個となる。

gtoolsパッケージのcombinations関数を使う。repeats.allowオプションをTRUEにすること。

> library(gtools)
> ss <- c("a", "b")
> combinations(2, 3, ss, repeats.allow = TRUE)
     [,1] [,2] [,3]
[1,] "a"  "a"  "a" 
[2,] "a"  "a"  "b" 
[3,] "a"  "b"  "b" 
[4,] "b"  "b"  "b"

複素数を使う

複素数を扱うには、複素数型ベクトルを使う。complex関数を使うか、+とi演算子を組み合わせることで、作ることができる。Rでは虚数単位をiで表す。iだけではiというオブジェクト（ベクトルやリストのこと）を表すため、虚部が1の場合は1iとする必要がある。complex関数はオプション名を省略すると、第一引数は作成するベクトルの数の指定になることに注意。

> z1 <- 2 + i
エラー: オブジェクト 'i' がありません
> z1 <- 2 + 1i
> z2 <- complex(real = 4, imaginary = 2)
> print(z1)
[1] 2+1i
> print(z2)
[1] 4+2i
> print(z1 + z2)
[1] 6+3i
> mode(z1)
[1] "complex"
> class(z1)
[1] "complex"
> typeof(z1)
[1] "complex"
> complex(real = 6, imaginary = 8)
[1] 6+8i
> complex(4, 6, 8)
[1] 6+8i 6+8i 6+8i 6+8i
> complex(1, c(3, 6), c(9, 12))
[1] 3+ 9i 6+12i
> complex(real = c(3, 6), imaginary = c(9, 12))
[1] 3+ 9i 6+12i

パスカルの三角形を作成する

choose関数とsapply関数を組合わせて使う。

> sapply(0:6, function(x) choose(x, 0:x))
[[1]]
[1] 1
[[2]]
[1] 1 1
[[3]]
[1] 1 2 1
[[4]]
[1] 1 3 3 1
[[5]]
[1] 1 4 6 4 1
[[6]]
[1]  1  5 10 10  5  1
[[7]]
[1]  1  6 15 20 15  6  1

組合せを得る

n個からr個とった組合せの数を得るにはchoose関数を使うが、その組合せ自体を得るにはcombn関数を使う。以下は5個の中から3個を選んだ例。5C3=10で異なる10通りの選び方がある。

> choose(5, 3)
[1] 10
> combn(1:5, 3)
     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,]    1    1    1    1    1    1    2    2    2     3
[2,]    2    2    2    3    3    4    3    3    4     4
[3,]    3    4    5    4    5    5    4    5    5     5
> combn(c("a", "b", "c", "d", "e"), 3)
     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,] "a"  "a"  "a"  "a"  "a"  "a"  "b"  "b"  "b"  "c"  
[2,] "b"  "b"  "b"  "c"  "c"  "d"  "c"  "c"  "d"  "d"  
[3,] "c"  "d"  "e"  "d"  "e"  "e"  "d"  "e"  "e"  "e"

平均を求める

mean関数を使う。ベクトルや行列を指定すると、全要素（成分）の算術平均（全標本の和を標本の数で割った値）を返す。

> x <- 1:18
> print(x)
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18
> sum(x) / length(x)
[1] 9.5
> mean(x)
[1] 9.5
> aa <- matrix(x, nrow = 3, ncol = 6, byrow = TRUE)
> print(aa)
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    2    3    4    5    6
[2,]    7    8    9   10   11   12
[3,]   13   14   15   16   17   18
> mean(aa)
[1] 9.5