はじめに

機械学習の勉強を始めたVBAユーザです。
備忘録としてPython・Rの文法をVBAと比較しながらまとめていきたいと思います。
今回は、ベクトル（1次元配列）に相当する機能についてまとめます。

目次

ベクトル
まとめ
- 一覧
- プログラム全体

ベクトル

今回は、ベクトル（1次元配列）に相当する機能についてまとめます。

ベクトルの作成

Python
Pythonには、複数の値をまとめて取り扱う複合データ型として、リスト（list）型、タプル（tuple）型、辞書（dictionary）型があります。また、数値計算ライブラリNumpyのndarray（多次元配列）の１次元のものはベクトルとして扱えます。ここでは主にリスト型（とタプル型）について扱います。Numpyのndarrayについては下の数ベクトルの項を参照。
リスト型は複数の値をカンマ区切りで並べて[``]囲みで、タプル型は(``)囲みで定義します。

Python3

[1,2,3,4,5]
v = [1,2,3,4,5]
v
# [1, 2, 3, 4, 5]
type(v)
# list

v = ['a','b','c','d','e']
v
# ['a', 'b', 'c', 'd', 'e']
v = list('abcde')
v
# ['a', 'b', 'c', 'd', 'e']
type(v)
# list

(1,2,3,4,5)
v = (1,2,3,4,5)
v
# (1, 2, 3, 4, 5)
type(v)
# tuple

v = ('a','b','c','d','e')
v
# ('a', 'b', 'c', 'd', 'e')
v = tuple('abcde')
v
# ('a', 'b', 'c', 'd', 'e')
type(v)
# tuple

R
Rには、オブジェクトの基本的な型（Basic types）としてベクトル型（Vector objects）とリスト型（List objects）があります。ベクトル型は同じ種類の要素からなるもの、リスト型は要素の種類が違ってもよいものです。ここではベクトル型のみ扱います。
なお、Rでは、数値1個でも要素数が1のベクトルとして扱います。

Rでは、c()関数でベクトルを作成します。

R

c(1,2,3,4,5)
v <- c(1,2,3,4,5)
v
# [1] 1 2 3 4 5
typeof(v) # "double"
mode(v)   # "numeric"

v <- as.integer(c(1,2,3,4,5))
v
typeof(v) # "integer"
mode(v)   # "numeric"

v <- c("A", "B", "C", "D", "E")
v
# [1] "A" "B" "C" "D" "E"
typeof(v) # "character"
mode(v)   # "character"

c(1,2,3,4,5)では実数（double）ベクトルができます。どうしても整数（integer）ベクトルにしたければ、as.integer()をつけることで整数ベクトルになります。

VBA
VBAでは、Array関数で（１次元）配列を作ることができます。配列のインデックスはデフォルトでは0から始まります。Option Base ステートメントで配列のインデックスの下限を1に変更することもできます。

VBA

Dim i As Integer

Dim v As Variant
v = Array(1, 2, 3, 4, 5)
Debug.Print LBound(v), UBound(v), UBound(v) - LBound(v) + 1
' 0             4             5
For i = LBound(v) To UBound(v)
    Debug.Print i, v(i)
Next i
' 0             1
' 1             2
' 2             3
' 3             4
' 4             5

Dim s As Variant
s = Array("a", "b", "c", "d", "e")
Debug.Print LBound(s), UBound(s), UBound(s) - LBound(s) + 1
' 0             4             5
For i = LBound(s) To UBound(s)
    Debug.Print i, s(i)
Next i
' 0             a
' 1             b
' 2             c
' 3             d
' 4             e

規則性のあるベクトルの作成

Python

Python3

# 等差数列
list(range(10))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list(range(1,10+1))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
list(range(1,10+1,1))
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

list(range(10,1-1,-1))
# [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

list(range(-5,5+1,1))
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

list(range(0,10+1))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list(range(0,10+1,2))
# [0, 2, 4, 6, 8, 10]

# 繰り返し
[1] * 10
# [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

list(range(1,3+1)) * 5
# [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

list(['A','B','C']) * 3
# ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C']

また、Numpyのndarrayを使うと長さを指定した等差数列などを作ることもできます。Numpyのndarrayについては下の数ベクトルの項を参照。

Python3

import numpy as np
np.linspace(0, 10, num=5+1)   # 長さ5+1
# array([ 0.,  2.,  4.,  6.,  8., 10.])
np.linspace(0, 10, num=5+1, endpoint=True)
# array([ 0.,  2.,  4.,  6.,  8., 10.])
np.linspace(0, 10, num=5, endpoint=False)
# array([0., 2., 4., 6., 8.])

np.zeros(10)
# array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
np.ones(10)
# array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])
np.full(10, 5)
# array([5, 5, 5, 5, 5, 5, 5, 5, 5, 5])

R

R

# 等差数列
1:10
# [1]  1  2  3  4  5  6  7  8  9 10
seq(1,10)
# [1]  1  2  3  4  5  6  7  8  9 10
seq(10)
# [1]  1  2  3  4  5  6  7  8  9 10
seq_len(10)
# [1]  1  2  3  4  5  6  7  8  9 10

10:1
# [1] 10  9  8  7  6  5  4  3  2  1
seq(10, 1, -1)
# [1] 10  9  8  7  6  5  4  3  2  1

-5:5
# [1] -5 -4 -3 -2 -1  0  1  2  3  4  5
seq(-5, 5)
# [1] -5 -4 -3 -2 -1  0  1  2  3  4  5

seq(0, 10)
# [1]  0  1  2  3  4  5  6  7  8  9 10

seq(0, 10, by=2)           # 2ずつ増加
# [1]  0  2  4  6  8 10

seq(0, 10, length.out=5+1) # 長さ5+1
seq(0, 10, length=5+1)
# [1]  0  2  4  6  8 10

# 繰り返し
rep(1, 10)
# [1] 1 1 1 1 1 1 1 1 1 1

rep(1:3, times=5)   # 5回繰り返し
# [1] 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3

rep(1:3, length=10) # 長さ10まで繰り返し
# [1] 1 2 3 1 2 3 1 2 3 1

rep(1:3, each=5)
# [1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3

rep(1:3, 1:3)
# [1] 1 2 2 3 3 3

rep(1:3, c(2, 1, 3))
# [1] 1 1 2 3 3 3

rep(1:3, each=3, times=2)
# [1] 1 1 1 2 2 2 3 3 3 1 1 1 2 2 2 3 3 3

rep(1:3, each=3, times=2, len=15)
# [1] 1 1 1 2 2 2 3 3 3 1 1 1 2 2 2

rep(c("A", "B", "C"), 3)
# [1] "A" "B" "C" "A" "B" "C" "A" "B" "C"

rep(c("A", "B", "C"), length=10)
# [1] "A" "B" "C" "A" "B" "C" "A" "B" "C" "A"

rep(c("A", "B", "C"), each=3)
# [1] "A" "A" "A" "B" "B" "B" "C" "C" "C"

rep(c("A", "B", "C"), 1:3)
# [1] "A" "B" "B" "C" "C" "C"

rep(c("A", "B", "C"), each=3, times=2)
# [1] "A" "A" "A" "B" "B" "B" "C" "C" "C" "A" "A" "A" "B" "B" "B" "C" "C" "C"

rep(c("A", "B", "C"), each=3, times=2, length=15)
# [1] "A" "A" "A" "B" "B" "B" "C" "C" "C" "A" "A" "A" "B" "B" "B"

rep(c("A", "B", "C"), 1:3, length=5)
# [1] "A" "B" "C" "A" "B"

numeric(10)   # 0を10個繰り返す
# [1] 0 0 0 0 0 0 0 0 0 0

sequence(c(1, 2, 3, 4, 5))
# [1] 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5
c(seq(1), seq(2), seq(3), seq(4), seq(5))
# [1] 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5
c(1:1, 1:2, 1:3, 1:4, 1:5)
# [1] 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5

1:10は整数（integer）ベクトルになります。

VBA

VBA

要素へのアクセス

要素の取得

要素のインデックスが0から始まるか1から始まるかは言語によって異なります。Pythonでは先頭の要素のインデックスは0、Rでは先頭の要素のインデックスは1です。また、インデックスに負の値を指定したときの意味も言語によって異なります。

Python
Pythonでは先頭の要素のインデックスは0です。また、インデックスに負の値を指定すると、末尾からの位置となります。

Python3

v = list(range(1,10+1,1))
print(v)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
v[0]
# 1

v[2]
# 3

v[1:5]
# [2, 3, 4, 5]

また、Numpyのndarrayを使うと次のような要素の取り出しもできます。Numpyのndarrayについては下の数ベクトルの項を参照。

Python3

import numpy as np
v = np.arange(1,10+1)
v
# array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])
v[0]
# 1
v[2-1:5]
# array([2, 3, 4, 5])
v[[1-1,3-1,5-1]]
# array([1, 3, 5])
v[v < 5]
# array([1, 2, 3, 4])
v[v % 2 == 0]
# array([ 2,  4,  6,  8, 10])
v[(v > 3) & (v < 7)]
# array([4, 5, 6])
v[(v < 3) | (v > 7)]
# array([ 1,  2,  8,  9, 10])

R
Pythonでは先頭の要素のインデックスは1です。また、インデックスに負の値を指定すると、そのインデックスの要素を除いたものとなります。

R

v <- 1:10
v
# [1]  1  2  3  4  5  6  7  8  9 10
v[1]
# [1] 1
v[3]
# [1] 3
v[2:5] 
# [1] 2 3 4 5
v[c(1,3,5)]
# [1] 1 3 5
v[-1]
# [1]  2  3  4  5  6  7  8  9 10
v[-1:-3]
# [1]  4  5  6  7  8  9 10
v[-(1:3)]
# [1]  4  5  6  7  8  9 10
v[c(-1,-3,-5)]
# [1]  2  4  6  7  8  9 10
v[-c(1,3,5)]
# [1]  2  4  6  7  8  9 10
v[v < 5]
# [1] 1 2 3 4
v[v %% 2 == 0]
# [1]  2  4  6  8 10
v[v > 3 & v < 7]
# [1] 4 5 6
v[v < 3 | v > 7]
# [1]  1  2  8  9 10

注意）負値の意味がPythonと異なるので注意。

VBA
VBAでは、配列のインデックスはデフォルトでは0から始まります。Option Base ステートメントで配列のインデックスの下限を1に変更することもできます。

VBA

Dim v As Variant
v = Array(1, 2, 3, 4, 5)
Debug.Print LBound(v), UBound(v), UBound(v) - LBound(v) + 1
' 0             4             5
For i = LBound(v) To UBound(v)
    Debug.Print i, v(i)
Next i
' 0             1
' 1             2
' 2             3
' 3             4
' 4             5
Debug.Print v(3 - 1)
' 3

Dim s As Variant
s = Array("a", "b", "c", "d", "e")
Debug.Print LBound(s), UBound(s), UBound(s) - LBound(s) + 1
' 0             4             5
For i = LBound(s) To UBound(s)
    Debug.Print i, s(i)
Next i
' 0             a
' 1             b
' 2             c
' 3             d
' 4             e
Debug.Print s(3 - 1)
' c

要素への代入

Python

Python3

v = list(range(1,10+1))
v
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
v[0] = 0
v
# [0, 2, 3, 4, 5, 6, 7, 8, 9, 10]
v[4-1:6] = [0,0,0]
v
# [0, 2, 3, 0, 0, 0, 7, 8, 9, 10]

また、Numpyのndarrayを使うと複数の要素への代入もできます。Numpyのndarrayについては下の数ベクトルの項を参照。

Python3

import numpy as np
v = np.arange(1.0,10+1)
v
# array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])
v[0] = 0
v
# array([ 0.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])
v[4-1:6] = 0
v
# array([ 0.,  2.,  3.,  0.,  0.,  0.,  7.,  8.,  9., 10.])
v[4-1:6] = np.nan
v
# array([ 0.,  2.,  3., nan, nan, nan,  7.,  8.,  9., 10.])

R

R

v <- 1:10
v
# [1]  1  2  3  4  5  6  7  8  9 10
v[1] <- 0
v
# [1]  0  2  3  4  5  6  7  8  9 10
v[4:6] <- NA
v
# [1]  0  2  3 NA NA NA  7  8  9 10

VBA
Dim w(5) As ・・・と宣言すると、wのインデックスは0から5までになります。
Dim x(2 To 5) As ・・・と宣言すると、xのインデックスは2から5までになります。
Dim y() As ・・・と宣言しておいて、ReDim y(5)とすると、yのインデックスは0から5までになります。その後、ReDim Preserve y(6)とすると、0から5までの要素をそのまま保ったままインデックスを6までにできます。

VBA

Debug.Print "v"
Dim v As Variant
v = Array(1, 2, 3, 4, 5)
Debug.Print LBound(v), UBound(v), UBound(v) - LBound(v) + 1
' 0             4             5
For i = LBound(v) To UBound(v)
    Debug.Print i, v(i)
Next i
' 0             1
' 1             2
' 2             3
' 3             4
' 4             5
Debug.Print v(3 - 1)
' 3

Debug.Print "w"
Dim w(5) As Integer
Debug.Print LBound(w), UBound(w), UBound(w) - LBound(w) + 1
' 0             5             6
For i = LBound(w) To UBound(w)
    w(i) = i
Next i
For i = LBound(w) To UBound(w)
    Debug.Print i, w(i)
Next i
' 0             0
' 1             1
' 2             2
' 3             3
' 4             4
' 5             5

Debug.Print "x"
Dim x(2 To 5) As Integer
Debug.Print LBound(x), UBound(x), UBound(x) - LBound(x) + 1
' 2             5             4
For i = LBound(x) To UBound(x)
    x(i) = i
Next i
For i = LBound(x) To UBound(x)
    Debug.Print i, x(i)
Next i
' 2             2
' 3             3
' 4             4
' 5             5

Debug.Print "y"
Dim y() As Integer
ReDim y(5)
Debug.Print LBound(y), UBound(y), UBound(y) - LBound(y) + 1
' 0             5             6
For i = LBound(y) To UBound(y)
    y(i) = i
Next i
ReDim Preserve y(6) ' 要素の追加
Debug.Print LBound(y), UBound(y), UBound(y) - LBound(y) + 1
' 0             6             7
y(6) = 6
For i = LBound(y) To UBound(y)
    Debug.Print i, y(i)
Next i
' 0             0
' 1             1
' 2             2
' 3             3
' 4             4
' 5             5
' 6             6

Debug.Print "z"
Dim z As Variant
z = Range("B2:B6")
Debug.Print LBound(z, 1), UBound(z, 1), UBound(z, 1) - LBound(z, 1) + 1
' 1             5             5
For i = LBound(z, 1) To UBound(z, 1)
    Debug.Print i, z(i, 1)
Next i
' 1             2
' 2             4
' 3             1
' 4             3
' 5             5

Excelのシートのセル範囲から読み込むと、2次元配列（1次元目のインデックスは1から）になります。

ベクトルの属性

長さ

Python

Python3

v = list(range(1,5+1))
len(v)
# 5

R

R

v <- 1:5
length(v)
# [1] 5

VBA

VBA

要素名

Python

Python3

R
Rでは、ベクトルにnames属性を指定することで、要素名を付けられます。そうしておくと、各要素に要素名でアクセスできるようになります。

R

names(v) <- paste("v", 1:5, sep="")
v
# v1 v2 v3 v4 v5 
#  1  2  3  4  5 
v["v3"]
# v3 
#  3

VBA

VBA

ベクトルの操作

要素の検索

Python

Python3

v = [2,4,1,3,5]
v
# [2, 4, 1, 3, 5]
1 in v
# True
0 in v
# False

v = list('BDACE')
v
# ['B', 'D', 'A', 'C', 'E']
'A' in v
# True
'Z' in v
# False

v = [2,2,4,4,4,4,1,3,3,3,5,5,5,5,5]
v.count(3)
# 3
v.count(0)
# 0

また、Numpyのndarrayを使うと条件に合うインデックスを求めることもできます。Numpyのndarrayについては下の数ベクトルの項を参照。

Python3

import numpy as np
v = np.array([2,4,1,3,5])
v
# array([2, 4, 1, 3, 5])
np.argwhere(v == 1)
# array([[2]], dtype=int64)
np.argwhere(v == 1).shape
# (1, 1)
np.argwhere(v <= 3)
# array([[0],
#        [2],
#        [3]], dtype=int64)
np.argwhere(v <= 3).shape
# (3, 1)

R

R

v <- c(2,4,1,3,5)
v
# [1] 2 4 1 3 5
which(v == 1)
# [1] 3
which(v <= 3)
# [1] 1 3 4
# which(2 <= v < 4) # エラー
which(2 <= v & v < 4)
# [1] 1 4
v[which(v == 1)]
# [1] 1
v[which(v <= 3)]
# [1] 2 1 3
v[which(2 <= v & v < 4)]
# [1] 2 3

v[v == 1]
# [1] 1
v[v <= 3]
# [1] 2 1 3
v[2 <= v & v < 4]
# [1] 2 3

1 %in% v
# [1] TRUE
0 %in% v
# [1] FALSE

v <- LETTERS[c(2,4,1,3,5)]
v
# [1] "B" "D" "A" "C" "E"
which(v == "A")
# [1] 3
which(v <= "C")
# [1] 1 3 4
which("B" <= v & v < "D")
# [1] 1 4
v[which(v == "A")]
# [1] "A"
v[which(v <= "C")]
# [1] "B" "A" "C"
v[which("B" <= v & v < "D")]
# [1] "B" "C"

v[v == "A"]
# [1] "A"
v[v <= "C"]
# [1] "B" "A" "C"
v[v >= "D" & v <= "F"]
# [1] "D" "E" "F"
v["B" <= v & v < "D"]
# [1] "B" "C"

"A" %in% v
# [1] TRUE
"Z" %in% v
# [1] FALSE

v <- c(1,2,NA,4,5)
v
is.na(v)
# [1] FALSE FALSE  TRUE FALSE FALSE
which(is.na(v))
# [1] 3
v[which(is.na(v))]
# [1] NA
v[is.na(v)]
# [1] NA
v[is.na(v)] <- 9
v
# [1] 1 2 9 4 5

注意）LETTERSについては、下の組み込み定数ベクトルを参照。

VBA

VBA

ソート等

Python

Python3

v = [2,4,1,3,5]
v
# [2, 4, 1, 3, 5]
v[::-1]
# [5, 3, 1, 4, 2]
sorted(v)
# [1, 2, 3, 4, 5]
sorted(v, reverse=True)
# [5, 4, 3, 2, 1]

v = [2,4,1,3,5]
v.reverse()
v
# [5, 3, 1, 4, 2]

v = [2,4,1,3,5]
v.sort()
v
# [1, 2, 3, 4, 5]

v = [2,4,1,3,5]
v.sort(reverse=True)
v
# # [5, 4, 3, 2, 1]

v = [2,4,1,3,5]
max(v)
# 5
min(v)
# 1

v = list('BDACE')
max(v)
# 'E'
min(v)
# 'A'

また、Numpyのndarrayを使うと次のようなこともできます。Numpyのndarrayについては下の数ベクトルの項を参照。

Python3

import numpy as np
v = np.array([2,4,1,3,5])
v
# array([2, 4, 1, 3, 5])
v[v == 1]
# array([1])
np.argsort(v)
# array([2, 0, 3, 1, 4], dtype=int64)
np.argsort(v)[::-1]
# array([4, 1, 3, 0, 2], dtype=int64)
np.sort(v)
# array([1, 2, 3, 4, 5])
np.sort(v)[::-1]
# array([5, 4, 3, 2, 1])

np.argmax(v)
# 4
np.argmin(v)
# 2
np.max(v)
# 5
np.min(v)
# 1
np.median(v)
# 3.0
np.percentile(v, [0,25,50,75,100])
# array([1., 2., 3., 4., 5.])

R

R

v <- c(2,4,1,3,5)
v
# [1] 2 4 1 3 5
rev(v)
# [1] 5 3 1 4 2
order(v)
# [1] 3 1 4 2 5
v[order(v)]
# [1] 1 2 3 4 5
sort(v)
# [1] 1 2 3 4 5
v[rev(order(v))]
# [1] 5 4 3 2 1
rev(sort(v))
# [1] 5 4 3 2 1
sort(v, decreasing=TRUE)
# [1] 5 4 3 2 1

max(v)
# [1] 5
min(v)
# [1] 1
median(v)
# [1] 3
range(v)
# [1] 1 5
quantile(v)
#   0%  25%  50%  75% 100% 
#    1    2    3    4    5 

v <- LETTERS[c(2,4,1,3,5)]
v
# [1] "B" "D" "A" "C" "E"
rev(v)
# [1] "E" "C" "A" "D" "B"
order(v)
# [1] 3 1 4 2 5
v[order(v)]
# [1] "A" "B" "C" "D" "E"
sort(v)
# [1] "A" "B" "C" "D" "E"
v[rev(order(v))]
# [1] "E" "D" "C" "B" "A"
rev(sort(v))
# [1] "E" "D" "C" "B" "A"
sort(v, decreasing=TRUE)
# [1] "E" "D" "C" "B" "A"

max(v)
# [1] "E"
min(v)
# [1] "A"
median(v)
# [1] "C"
range(v)
# [1] "A" "E"

VBA

VBA

集合演算

\begin{eqnarray*}
v &=& (2,2,4,4,4,4,1,3,3,3,5,5,5,5,5) \\
A &=& \{2,4,1,3,5\} \\
B &=& \{1,3,5,7,9\} \\
a &=& 1
\end{eqnarray*}

\begin{eqnarray*}
A \cup B &=& \{2,4,1,3,5,7,9\} \quad &和集合 \\
A \cap B &=& \{1,3,5\} &積集合 \\
A \cap B^{c} = A \setminus B &=& \{2,4\} &差集合 \\
(A \setminus B) \cup (B \setminus A) = A \triangle B &=& \{2,4,7,9\} &対称差集合 \\
A = B && &集合として等しい \\
a \in A && &要素
\end{eqnarray*}

Python
Pythonには、集合（set）を扱うための集合（set）型があります。

Python3

v = [2,2,4,4,4,4,1,3,3,3,5,5,5,5,5]
v
A = set(v) # 重複削除
A
# {1, 2, 3, 4, 5}
B = {1,3,5,7,9}
B
# {1, 3, 5, 7, 9}
A | B      # 和集合（union）
# {1, 2, 3, 4, 5, 7, 9}
A & B      # 積集合（intersection）
# {1, 3, 5}
A - B      # 差集合（difference）
# {2, 4}
A ^ B      # 対称差集合（symmetric difference）
# {2, 4, 7, 9}
A == B
# False
A in B
# False
1 in A
# True
0 in A
# False
set()      # 空集合
# set()

v = list('BBDDDDACCCEEEEE')
v
A = set(v) # 重複削除
A
# {'A', 'B', 'C', 'D', 'E'}
B = set('ACEGI')
B
# {'A', 'C', 'E', 'G', 'I'}
A | B      # 和集合（union）
# {'A', 'B', 'C', 'D', 'E', 'G', 'I'}
A & B      # 積集合（intersection）
# {'A', 'C', 'E'}
A - B      # 差集合（difference）
# {'B', 'D'}
A ^ B      # 対称差集合（symmetric difference）
# {'B', 'D', 'G', 'I'}
A == B
# False
A in B
# False
'A' in B
# True
'Z' in B
# False

R
Rでは、ベクトルを集合とみなして集合演算が行えます。

R

v <- c(2,2,4,4,4,4,1,3,3,3,5,5,5,5,5)
unique(v)        # 重複削除
# [1] 2 4 1 3 5
A <- unique(v)
B <- c(1,3,5,7,9)
union(A, B)      # 和集合
# [1] 2 4 1 3 5 7 9
intersect(A, B)  # 積集合
# [1] 1 3 5
setdiff(A, B)    # 差集合
# [1] 2 4
setequal(A, B)   # 集合として等しいか
# [1] FALSE
is.element(A, B) # 第1引数の各要素が第2引数の集合に含まれるか
# [1] FALSE FALSE  TRUE  TRUE  TRUE
A %in% B
# [1] FALSE FALSE  TRUE  TRUE  TRUE
is.element(1, B) # 集合の要素か
# [1] TRUE
1 %in% B
# [1] TRUE
0 %in% B
# [1] FALSE

v <- LETTERS[c(2,2,4,4,4,4,1,3,3,3,5,5,5,5,5)]
v
unique(v)        # 重複削除
A <- unique(v)
A
# [1] "B" "D" "A" "C" "E"
B <- LETTERS[c(1,3,5,7,9)]
B
# [1] "A" "C" "E" "G" "I"
unique(A)
# [1] "B" "D" "A" "C" "E"
union(A, B)        # 和集合
# [1] "B" "D" "A" "C" "E" "G" "I"
intersect(A, B)    # 積集合
# [1] "A" "C" "E"
setdiff(A, B)      # 差集合
# [1] "B" "D"
setequal(A, B)     # 集合として等しいか
# [1] FALSE
is.element(A, B)   # 第1引数の各要素が第2引数の集合に含まれるか
# [1] FALSE FALSE  TRUE  TRUE  TRUE
A %in% B
# [1] FALSE FALSE  TRUE  TRUE  TRUE
is.element("A", B) # 集合の要素か
# [1] TRUE
"A" %in% B
# [1] TRUE
"Z" %in% B
# [1] FALSE

VBA

VBA

要素の置換

Python

Python3

R

R

v <- c(2,4,1,3,5)
v
# [1] 2 4 1 3 5
replace(v, c(1,3,5), c(10,30,50))
# [1] 10  4 30  3 50
replace(v, 2:3, NA)
# [1]  2 NA NA  3  5
w <- replace(v, 2:3, NA)
replace(w, which(is.na(w)), 99)
# [1]  2 99 99  3  5

v <- LETTERS[c(2,4,1,3,5)]
v
# [1] "B" "D" "A" "C" "E"
replace(v, c(1,3,5), letters[c(1,3,5)])
# [1] "a" "D" "c" "C" "e"
replace(v, 2:3, NA)
# [1] "B" NA  NA  "C" "E"
w <- replace(v, 2:3, NA)
replace(w, which(is.na(w)), "Z")
# [1] "B" "Z" "Z" "C" "E"

VBA

VBA

ベクトルの結合と挿入

Python

Python3

# 結合
u = [1,2,3]
v = [4,5]
w = [6,7,8,9]
u + v + w
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

u.extend(v)
u.extend(w)
u
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 挿入
u = [1,2,3]
v = [4,5]
u.insert(2, v[0])
u.insert(3, v[1])
u
# [1, 2, 4, 5, 3]

# 要素の追加
v = []
print(v)
# []
v.append(1)
v.append(2)
v[len(v):] = [3]
print(v)
# [1, 2, 3]

v = list()
print(v)
# []
v.append('A')
v.append('B')
v.append('C')
print(v)
# ['A', 'B', 'C']

R

R

# ベクトルの結合
u <- 1:3
v <- 4:5
w <- 6:9
u
# [1] 1 2 3
v
# [1] 4 5
w
# [1] 6 7 8 9
c(u, v, w)
# [1] 1 2 3 4 5 6 7 8 9
c(w, v, u)
# [1] 6 7 8 9 4 5 1 2 3
append(u, v)
# [1] 1 2 3 4 5
append(append(u, v), w)
# [1] 1 2 3 4 5 6 7 8 9

# ベクトルの挿入
append(u, v, after=2)
# [1] 1 2 4 5 3

# 要素の追加
v <- 1:2
v
# [1] 1 2
append(v, 3)
# [1] 1 2 3

v <- c()
v
# NULL
v <- append(v, 1)
v <- append(v, 2)
v <- append(v, 3)
v
# [1] 1 2 3

VBA

VBA

ベクトルの要素の削除

Python

Python3

# 削除
v = [1,2,3,4,5]
v.remove(3)
v
# [1, 2, 4, 5]

v = [1,2,3,4,5]
v.clear()
v
# []

v = [1,2,3,4,5]
del v[:]
v
# []

v = list(range(1,5+1))
print(v)
# [1, 2, 3, 4, 5]
v.pop()
# 5
print(v)
# [1, 2, 3, 4]
v.pop()
# 4
print(v)
# [1, 2, 3]
v.pop()
# 3
print(v)
# [1, 2]
v.pop()
# 2
print(v)
# [1]
v.pop()
# 1
print(v)
# []

v = list(range(5))
print(v)
# [0, 1, 2, 3, 4]
del v[0]
print(v)
# [1, 2, 3, 4]
del v[2]
print(v)
# [1, 2, 4]
del v   # 変数自体の削除
print(v)
# NameError: name 'v' is not defined

R

R

VBA

VBA

数ベクトル

ここからは数ベクトルの計算です。

数ベクトルの定義

Python
Pythonの数値計算ライブラリNumpy（ナムパイ）を使います。Numpyのndarrayは多次元配列ですが、その１次元のものが数ベクトルとして扱えます。

Python3

import numpy as np
v = np.array([1,2,3,4,5])
v
# array([1, 2, 3, 4, 5])
type(v)
# numpy.ndarray
len(v)
# 5

np.arange(10)
# array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.arange(0,10+1)
# array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])
np.arange(0,10+1,2)
# array([ 0,  2,  4,  6,  8, 10])
np.linspace(0, 10, num=5+1) # 長さ5+1
# array([ 0.,  2.,  4.,  6.,  8., 10.])
np.linspace(0, 10, num=5+1, endpoint=True)
# array([ 0.,  2.,  4.,  6.,  8., 10.])
np.linspace(0, 10, num=5, endpoint=False)
# array([0., 2., 4., 6., 8.])

np.zeros(10)
# array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
np.ones(10)
# array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])
np.full(10, 5)
# array([5, 5, 5, 5, 5, 5, 5, 5, 5, 5])

v = np.arange(1,10+1)
v
# array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])
v[0]
# 1
v[2-1:5]
# array([2, 3, 4, 5])
v[[1-1,3-1,5-1]]
# array([1, 3, 5])
v[v < 5]
# array([1, 2, 3, 4])
v[v % 2 == 0]
# array([ 2,  4,  6,  8, 10])
v[(v % 2 == 0) & (v < 5)]
# array([2, 4])
v[(v > 3) & (v < 7)]
# array([4, 5, 6])
v[(v < 3) | (v > 7)]
# array([ 1,  2,  8,  9, 10])

R
Rでは、c()で定義する数値型のベクトルです。標準パッケージで使えます。（詳しくは上述）

R

v <- c(1,2,3,4,5)
v
# [1] 1 2 3 4 5

VBA

VBA

要素ごとの計算

ベクトルの要素ごと（element-wise）の演算です。

Python
Numpyのndarrayの要素ごとの演算に使える関数はここに挙げた以外にも多数用意されています（詳細はこちら）。

Python3

import numpy as np
v = np.array([2,4,1,3,5])
v
# array([2, 4, 1, 3, 5])
w = np.array([1,3,5,7,9])
w
# array([1, 3, 5, 7, 9])
v + w
# array([ 3,  7,  6, 10, 14])
v - w
# array([ 1,  1, -4, -4, -4])
v * w
# array([ 2, 12,  5, 21, 45])
v / w
# array([2.        , 1.33333333, 0.2       , 0.42857143, 0.55555556])
v + 1
# array([3, 5, 2, 4, 6])
v * 2
# array([ 4,  8,  2,  6, 10])
v ** 2
# array([ 4, 16,  1,  9, 25], dtype=int32)
v % 2
# array([0, 0, 1, 1, 1], dtype=int32)
1 / v
# array([0.5       , 0.25      , 1.        , 0.33333333, 0.2       ])
v < 3
# array([ True, False,  True, False, False])
v == 3
# array([False, False, False,  True, False])
v % 2 == 0
# array([ True,  True, False, False, False])
np.sqrt(v)
# array([1.41421356, 2.        , 1.        , 1.73205081, 2.23606798])
np.exp(v)
# array([  7.3890561 ,  54.59815003,   2.71828183,  20.08553692,
#        148.4131591 ])

R

R

v <- 1:5
v
# [1] 1 2 3 4 5
w <- seq(1, 10, by=2)
w
# [1] 1 3 5 7 9
v + w
# [1]  2  5  8 11 14
v - w
# [1]  0 -1 -2 -3 -4
v * w
# [1]  1  6 15 28 45
v / w
# [1] 1.0000000 0.6666667 0.6000000 0.5714286 0.5555556

v + 1
# [1] 2 3 4 5 6
v * 2
# [1]  2  4  6  8 10
1 / v
# [1] 1.0000000 0.5000000 0.3333333 0.2500000 0.2000000

v < 3
# [1]  TRUE  TRUE FALSE FALSE FALSE
v == 3
# [1] FALSE FALSE  TRUE FALSE FALSE
v %% 2 == 0
# [1] FALSE  TRUE FALSE  TRUE FALSE

sqrt(v)
# [1] 1.000000 1.414214 1.732051 2.000000 2.236068
exp(v)
# [1]   2.718282   7.389056  20.085537  54.598150 148.413159

VBA

VBA

統計量の計算

\begin{eqnarray*}
&x &=& (x_i)^{n}_i &= (2,4,1,3,5) \\
&y &=& (y_i)^{n}_i &= (1,3,5,7,9)
\end{eqnarray*}

\begin{eqnarray*}
\mathrm{max}(x) &=& \max_{i=1}^n x_i &最大値\\
\mathrm{min}(x) &=& \min_{i=1}^n x_i &最小値\\
\mathrm{sum}(x) &=& \sum_{i=1}^n x_i &総和\\
\mathrm{prod}(x) &=& \prod_{i=1}^n x_i &総積\\
\overline{x} &=& \frac{1}{n} \sum_{i=1}^n x_i &平均\\
s_x^2 &=& \frac{1}{n} \sum_{i=1}^n \left( x_i - \overline{x} \right)^2 &分散\\
var(x) = u_x^2 &=& \frac{1}{n-1} \sum_{i=1}^n \left( x_i - \overline{x} \right)^2 &不偏分散\\
s_x =  \sqrt{s_x^2} &=& \sqrt{ \frac{1}{n} \sum_{i=1}^n \left( x_i - \overline{x} \right)^2 } &標準偏差\\
\sqrt{var(x)} = u_x = \sqrt{u^2} &=& \sqrt{ \frac{1}{n-1} \sum_{i=1}^n \left( x_i - \overline{x} \right)^2 } &不偏標準偏差\\
s_{xy} &=& \frac{1}{n} \sum_{i=1}^n \left( x_i - \overline{x} \right) \left( y_i - \overline{y} \right) \quad &共分散 \\
cov(x,y) &=& \frac{1}{n-1} \sum_{i=1}^n \left( x_i - \overline{x} \right) \left( y_i - \overline{y} \right) &不偏共分散 \\
r_{xy} = \frac{s_{xy}}{s_x s_y} = \frac{cov(x,y)}{\sqrt{var(x)var(y)}} &=& \frac{\sum_{i=1}^n \left( x_i - \overline{x} \right) \left( y_i - \overline{y} \right)}{\sqrt{\sum_{i=1}^n \left( x_i - \overline{x} \right)^2}\sqrt{\sum_{i=1}^n \left( y_i - \overline{y} \right)^2}} \quad &相関係数 \\
Cov(x,y) &=& \begin{pmatrix}
   var(x) & cov(x,y) \\
   cov(x,y) & var(y)
\end{pmatrix} &分散共分散行列 \\
C_{xy} &=& \begin{pmatrix}
   1 & r_{xy} \\
   r_{xy} & 1
\end{pmatrix} &相関係数行列 \\
\end{eqnarray*}

Python

Python3

import numpy as np
x = np.array([2,4,1,3,5])
x
# array([2, 4, 1, 3, 5])
y = np.array([1,3,5,7,9])
y
# array([1, 3, 5, 7, 9])
max(x)
np.max(x)
# 5
min(x)
np.min(x)
# 1
np.median(x)
# 3.0
np.ptp(x)     # Range of values (maximum - minimum)
# 4
np.percentile(x, 25)
# 2.0
np.percentile(x, [0,25,50,75,100])
# array([1., 2., 3., 4., 5.])
np.quantile(x, 0.25)
# 2.0
np.quantile(x, [0,0.25,0.5,0.75,1])
# array([1., 2., 3., 4., 5.])

sum(x)
np.sum(x)
# 15
np.prod(x)
# 120
np.mean(x)
# 3.0
np.average(x, weights=y)   # weighted average
# 3.4
np.var(x)
# 2.0
np.var(x)*len(x)/(len(x)-1)
np.var(x, ddof=1)
# 2.5
np.std(x)
# 1.4142135623730951
np.std(x)*np.sqrt(len(x)/(len(x)-1))
np.std(x, ddof=1)
# 1.5811388300841898
np.cov(x, y, ddof=0)   # 分散共分散行列（covariance matrix）
# array([[2., 2.],
#        [2., 8.]])
np.cov(x, y, ddof=1)
# array([[ 2.5,  2.5],
#        [ 2.5, 10. ]])
np.corrcoef(x,y)   # 相関係数行列
# array([[1. , 0.5],
#        [0.5, 1. ]])

R

R

x <- c(2,4,1,3,5)
x
# [1] 2 4 1 3 5
y <- seq(1, 10, by=2)
y
# [1] 1 3 5 7 9
max(x)      # 最大値
# [1] 5
min(x)      # 最小値
# [1] 1
median(x)   # 中央値
# [1] 3
sum(x)      # 総和
# [1] 15
prod(x)     # 総積
# [1] 120
mean(x)     # 平均
# [1] 3
var(x)*((length(x)-1)/length(x))    # 分散
# [1] 2
var(x)      # 不偏分散
# [1] 2.5
sd(x)*sqrt((length(x)-1)/length(x)) # 標準偏差
# [1] 1.414214
sd(x)       # 不偏標準偏差
# [1] 1.581139
cov(x, y)*((length(x)-1)/length(x)) # 共分散
# [1] 2
cov(x, y)   # 不偏共分散
# [1] 2.5
cor(x, y)   # 相関係数
# [1] 0.5

# summary
summary(x)
# Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
# 1.00    3.25    5.50    5.50    7.75   10.00

VBA

VBA

累積計算

Python

Python3

import numpy as np
x = np.array([2,4,1,3,5])
x
# array([2, 4, 1, 3, 5])
np.cumsum(x)
# array([ 2,  6,  7, 10, 15], dtype=int32)
np.cumprod(x)
# array([  2,   8,   8,  24, 120], dtype=int32)
np.diff(x)   # 階差数列
# array([ 2, -3,  2,  2])
np.diff(x, n=1)   # 第1階差
# array([ 2, -3,  2,  2])
np.diff(x, n=2)   # 第2階差
# array([-5,  5,  0])
np.diff(x, n=3)   # 第3階差
# array([10, -5])
np.diff(x, n=4)   # 第4階差
# array([-15])

# リスト内包表記で
[sum(x[:i+1]) for i in range(len(x))]
# [2, 6, 7, 10, 15]
[np.prod(x[:i+1]) for i in range(len(x))]
# [2, 8, 8, 24, 120]
[np.max(x[:i+1]) for i in range(len(x))]
# [2, 4, 4, 4, 5]
[np.min(x[:i+1]) for i in range(len(x))]
# [2, 2, 1, 1, 1]
[x[i+1] - x[i] for i in range(len(x)-1)]
# [2, -3, 2, 2]

R

R

# 累積和等
x <- c(2,4,1,3,5)
cumsum(x)   # cumulative sums（累積和）
# [1]  2  6  7 10 15
cumprod(x)  # cumulative products
# [1]   2   8   8  24 120
cummax(x)   # cumulative max
# [1] 2 4 4 4 5
cummin(x)   # cumulative min
# [1] 2 2 1 1 1
diff(x)     # lagged differences（前進差分）
# [1]  2 -3  2  2

VBA

VBA

線形代数の計算

\begin{eqnarray*}
&x &=& (x_i)^{n}_i &= (2,4,1,3,5) \\
&y &=& (y_i)^{n}_i &= (1,3,5,7,9)
\end{eqnarray*}

\begin{eqnarray*}
(x,y) &=& \sum_{i=1}^n x_iy_i &内積 \\
\|x\| = \sqrt{(x,x)} &=& \sqrt{\sum_{i=1}^n {x_i}^2} \quad &ノルム \\
\end{eqnarray*}

Python

Python3

import numpy as np
v = np.array([2,4,1,3,5])
v
# array([2, 4, 1, 3, 5])
w = np.array([1,3,5,7,9])
w
# array([1, 3, 5, 7, 9])
np.dot(v, w)      # 内積
# 85
np.linalg.norm(v) # ノルム
# 7.416198487095663

R

R

v <- c(2,4,1,3,5)
v
# [1] 2 4 1 3 5
w <- c(1,3,5,7,9)
w
# [1] 1 3 5 7 9
sum(v * w)       # 内積
# [1] 85
sqrt(sum(v*v))   # ノルム
# [1] 7.416198487095663

VBA

VBA

組み込み定数ベクトル

Python
Rのlettersのような定数文字ベクトルはありませんが、簡単に作れます。

Python3

alphabets = 'abcdefghijklmnopqrstuvwxyz'
list(alphabets)[0:10]
# ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
list(alphabets.upper()[0:10])
# ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']

R

R

LETTERS
# [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "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" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"
month.abb
# [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
month.name
# [1] "January"   "February"  "March"     "April"     "May"       "June"      "July"      "August"    "September" "October"   "November"  "December" 
options(digits=22)
pi
# [1] 3.1415926535897931

LETTERS[1:10]
# [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J"
letters[1:10]
# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"
month.abb[4:6]
# [1] "Apr" "May" "Jun"
month.name[4:6]
# [1] "April" "May"   "June"

VBA

VBA

まとめ

一覧

各言語で使用する関数等を一覧にまとめます。比較のために、EXCELでの計算も示せるものについては示しました。

ベクトルの作成

	Python	Python(Numpy)	R	VBA	EXCEL	結果
ベクトルの作成	`[1,2,3,4,5]`	`np.array([1,2,3,4,5])`	`c(1,2,3,4,5)`	`Array(` `1, 2,` `3, 4,` `5)`	セル入力	1,2,3,4,5
1,...,n	`list(` `range(1,10+1))`	`np.arange(1,10+1)`	`seq(10)`		`=1つ前+1`	1,2,...,10
連続する整数列	`list(` `range(1,10+1,1))`	`np.arange(1,10+1,1)`	`1:10` `seq(1,10)`		`=1つ前+1`	1,2,...,10
連続する整数列	`list(` `range(10,1-1,-1))`	`np.arange(10,1-1,-1)`	`10:1` `seq(1,10,-1)`		`=1つ前-1`	10,9,...,1
等差数列	`list(` `range(0,10+1,2))`	`np.arange(0,10+1,2)`	`seq(0,10,by=2)`		`=1つ前+2`	0,2,4,6,8,10
等差数列		`np.linspace(0,10,` `num=5+1)`	`seq(0,10,` `length=5+1)`			0,2,4,6,8,10
繰り返し	`[1] * 10`	`np.full(10,1)`	`rep(1,10)`		`=1つ前`	1,1,...,1
繰り返し	`[1,2,3] * 5`		`rep(1:3,times=5)`		`=3つ前`	1,2,3,...,1,2,3
繰り返し			`rep(1:3,length=5)`			1,2,3,...,2,3,1
繰り返し			`rep(1:3,each=5)`			1,...,1,2,...,3,...
0を繰り返し	`[0]*10`	`np.zeros(10)`	`numeric(10)` `rep(0,10)`		`=0`	0,0,...,0
1,1,2, 1,2,3,...			`sequence(1:3)` `c(seq(1),seq(2),` `seq(3))` `c(1:1,1:2,1:3)`			1,1,2,1,2,3
重複削除	`list(set(` `[1,2,2,3,3,3]))`		`unique(` `c(1,2,2,3,3,3))`			1,2,3

ベクトルの属性

	Python	Python(Numpy)	R	VBA	EXCEL
長さ	`len(v)`	`len(v)`	`length(v)`	`UBound(v, 1)` `- LBound(v, 1)` `+ 1`
要素の型			`typeof(v)` `mode(v)`

要素へのアクセス
$v=(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)$

Python(Numpy)	R	EXCEL	結果
`v[3-1]`	`v[3]`	`=INDEX( ,3)`	3
`v[2-1:5]`	`v[2:5]`		2,3,4,5
`v[[1-1,3-1,5-1]]`	`v[c(1,3,5)]`		1,3,5
	`v[-1]`		2,3,...,10
	`v[c(-1,-3,-5)]` `v[-c(1,3,5)]`		2,4,6,7 ,8,9,10
`v[v < 5]`	`v[v < 5]`		1,2,3,4
`v[v % 2 == 0]`	`v[v %% 2 == 0]`		2,4,6,8,10
`v[(v > 3) & (v < 7)]`	`v[v > 3 & v < 7]`		4,5,6
`v[(v < 3)｜(v > 7)]`	`v[v < 3｜v > 7]`		1,2,8,9,10
	`v[is.na(v)]`
`v[:n]`	`head(v,n)`		1,2,...
`v[-n:]`	`tail(v,n)`		...,9,10

要素の検索

	Python	Python(Numpy)	R	EXCEL
条件に合う要素番号		`np.argwhere(v==1)`	`which(v==1)` `which(v<50)`	`=MATCH(1, ,0)`
条件に合う要素		`v[v<5]`	`v[which(v<5)]` `v[v < 5]`
要素にあるか	`1 in v`		`1 %in% v`	`=MATCH(1, ,0)>0`
条件に合う要素のカウント	`v.count(0)`	`len(v[v==0])`
NAか			`is.na(v)`

ベクトルの操作
$v = (2,4,1,3,5)$

	Python	Python(Numpy)	R	EXCEL	結果
逆順	`v[::-1]` `v.reverse()`	`v[::-1]`	`rev(v)`		5,3,1,4,2
昇順順位		`np.argsort(v)`	`order(v)`		3,1,4,2,5
降順順位		`np.argsort(v)[::-1]`	`order(v)`
昇順ソート	`sorted(v)` `v.sort()`	`np.sort(v)`	`sort(v)` `v[order(v)]`		1,2,3,4,5
降順ソート	`sorted(v,` `reverse=True)` `v.sort(` `reverse=True)`	`np.sort(v)[::-1]`	`rev(sort(v))` `sort(v,` `decreasing=T)` `v[rev(order(v))]`		5,4,3,2,1
最大要素番号		`np.argmax(v)`			4
最小要素番号		`np.argmin(v)`			2
最大要素	`max(v)`	`np.max(v)`	`max(v)`	`=MAX(V)`	5
最小要素	`min(v)`	`np.min(v)`	`min(v)`	`=MIN(V)`	1
中央値		`np.median(v)`	`median(v)`	`=MEDIAN(V)`	3
範囲			`range(v)`		1,5
範囲		`np.ptp(v)`			4
四分位		`np.percentile(v,` `[0,25,50,75,100])` `np.quantile(v,` `[0,0.25,0.5,0.75,1])`	`quantile(v)`	`=QUARTILE( ,n)` n： 0,1,2,3,4	第1四分位:2, 第3四分位:4
summary			`summary(v)`

集合演算

\begin{eqnarray*}
v &=& (2,2,4,4,4,4,1,3,3,3,5,5,5,5,5) \\
A &=& \{2,4,1,3,5\} \\
B &=& \{1,3,5,7,9\} \\
a &=& 1
\end{eqnarray*}

\begin{eqnarray*}
A \cup B &=& \{2,4,1,3,5,7,9\} \quad &和集合 \\
A \cap B &=& \{1,3,5\} &積集合 \\
A \cap B^{c} = A \setminus B &=& \{2,4\} &差集合 \\
(A \setminus B) \cup (B \setminus A) = A \triangle B &=& \{2,4,7,9\} &対称差集合 \\
A = B && &集合として等しい \\
a \in A && &要素
\end{eqnarray*}

	Python	R	結果
重複削除	`set(v)`	`unique(v)`	2,4,1,3,5
和集合	`A ｜ B`	`union(A,B)`	2,4,1,3,5,7,9
積集合	`A & B`	`intersect(A,B)`	1,3,5
差集合	`A - B`	`setdiff(A,B)`	2,4
対称差集合	`A ^ B`		2,4,7,9
集合として等しい	`A == B`	`setequal(A,B)`	False
要素	`a in A`	`is.element(a,A)` `a %in% A`	True
注意）Pythonではset型を使う。Rではベクトルを集合とみなして集合演算ができる。

ベクトルの要素の置換・結合・挿入

	Python	R
置換		`replace(v,要素,w)`
結合	`u + v + w`	`c(u,v,w)` `append(u,v)`
挿入		`append(u,v,after=n)`
挿入	`v.append(3)`	`append(v,3)`
削除	`v.remove(3)`

要素ごとの計算

	Python(Numpy)	R	EXCEL
v+w	`v + w`	`v + w`	`=V+W`
v-w	`v - w`	`v - w`	`=V-W`
v*w	`v * w`	`v * w`	`=V*W`
v/w	`v / w`	`v / w`	`=V/W`
v+1	`v + 1`	`v + 1`	`=V+1`
v*2	`v * 2`	`v * 2`	`=V*2`
1/v	`1 / v`	`1 / v`	`=1/V`
v < 3	`v < 3`	`v < 3`	`=V<3`
v = 3	`v == 3`	`v == 3`	`=V=W`
v/2の余り=0	`v % 2 == 0`	`v %% 2 == 0`	`=MOD(V,2)=0`
$\sqrt{v}$	`np.sqrt(v)`	`sqrt(v)`	`=SQRT(V)`
$\exp{v}$	`np.exp(v)`	`exp(v)`	`=EXP(V)`

統計量の計算

\begin{eqnarray*}
&x &=& (x_i)^{n}_i &= (2,4,1,3,5) \\
&y &=& (y_i)^{n}_i &= (1,3,5,7,9)
\end{eqnarray*}

\begin{eqnarray*}
\mathrm{max}(x) &=& \max_{i=1}^n x_i &最大値\\
\mathrm{min}(x) &=& \min_{i=1}^n x_i &最小値\\
\mathrm{sum}(x) &=& \sum_{i=1}^n x_i &総和\\
\mathrm{prod}(x) &=& \prod_{i=1}^n x_i &総積\\
\overline{x} &=& \frac{1}{n} \sum_{i=1}^n x_i &平均\\
s_x^2 &=& \frac{1}{n} \sum_{i=1}^n \left( x_i - \overline{x} \right)^2 &分散\\
var(x) = u_x^2 &=& \frac{1}{n-1} \sum_{i=1}^n \left( x_i - \overline{x} \right)^2 &不偏分散\\
s_x =  \sqrt{s_x^2} &=& \sqrt{ \frac{1}{n} \sum_{i=1}^n \left( x_i - \overline{x} \right)^2 } &標準偏差\\
\sqrt{var(x)} = u_x = \sqrt{u^2} &=& \sqrt{ \frac{1}{n-1} \sum_{i=1}^n \left( x_i - \overline{x} \right)^2 } &不偏標準偏差\\
s_{xy} &=& \frac{1}{n} \sum_{i=1}^n \left( x_i - \overline{x} \right) \left( y_i - \overline{y} \right) \quad &共分散 \\
cov(x,y) &=& \frac{1}{n-1} \sum_{i=1}^n \left( x_i - \overline{x} \right) \left( y_i - \overline{y} \right) &不偏共分散 \\
r_{xy} = \frac{s_{xy}}{s_x s_y} = \frac{cov(x,y)}{\sqrt{var(x)var(y)}} &=& \frac{\sum_{i=1}^n \left( x_i - \overline{x} \right) \left( y_i - \overline{y} \right)}{\sqrt{\sum_{i=1}^n \left( x_i - \overline{x} \right)^2}\sqrt{\sum_{i=1}^n \left( y_i - \overline{y} \right)^2}} \quad &相関係数 \\
Cov(x,y) &=& \begin{pmatrix}
   var(x) & cov(x,y) \\
   cov(x,y) & var(y)
\end{pmatrix} &分散共分散行列 \\
C_{xy} &=& \begin{pmatrix}
   1 & r_{xy} \\
   r_{xy} & 1
\end{pmatrix} &相関係数行列 \\
\end{eqnarray*}

Excelシートにはセル範囲 B2:B6, C2:C6 にベクトル $x,y$ の値が入力されているとする。

	Python	Python(Numpy)	R	EXCEL	結果
最大値	`max(x)`	`np.max(x)`	`max(x)`	`=MAX(B2:B6)`	5
最小値	`min(x)`	`np.min(x)`	`min(x)`	`=MIN(B2:B6)`	1
中央値		`np.median(x)`	`median(x)`	`=MEDIAN(B2:B6)`	3
範囲		`np.ptp(x)`			4
四分位		`np.percentile(x,25)` `np.quantile(x,0.25)`			2
総和	`sum(x)`	`np.sum(x)`	`sum(x)`	`=SUM(B2:B6)`	15
総積		`np.prod(x)`	`prod(x)`	`=PRODUCT(B2:B6)`	120
平均		`np.mean(x)`	`mean(x)`	`=AVERAGE(B2:B6)`	3
分散		`np.var(x)`	`var(x)*(n-1)/n`	`=VAR.P(B2:B6)` `=VARP(B2:B6)`	2
不偏分散		`np.var(x,ddof=1)`	`var(x)`	`=VAR.S(B2:B6)` `=VAR(B2:B6)`	2.5
標準偏差		`np.std(x)`	`sd(x)sqrt(` `var(x)(n-1)/n)`	`=STDEV.P(B2:B6)` `=STDEVP(B2:B6)`	1.414
不偏標準偏差		`np.std(x,ddof=1)`	`sd(x)`	`=STDEV.S(B2:B6)` `=STDEV(B2:B6)`	1.581
共分散			`cov(x,y)*(n-1)/n`	`=COVARIANCE.P(` `B2:B6,C2:C6)` `=COVAR(` `B2:B6,C2:C6)`	2
不偏共分散			`cov(x,y)`	`=COVARIANCE.S(` `B2:B6,C2:C6)`	2.5
相関係数			`cor(x,y)`	`=CORREL(` `B2:B6,C2:C6)`	0.5
分散共分散行列		`np.cov(x,y)`
相関係数行列		`np.corrcoef(x,y)`
summary			`summary(v)`

累積計算

	Python	Python(Numpy)	R	EXCEL	結果
cumsum 累積和	注意）	`np.cumsum(x)`	`cumsum(x)`	`=SUM($B$2:$B2)`	2,6,7,10,15
cumprod	注意）	`np.cumprod(x)`	`cumprod(x)`	`=PRODUCT($B$2:$B2)`	2,8,8,24,120
cummax	注意）		`cummax(x)`	`=MAX($B$2:$B2)`	2,4,4,4,5
cummin	注意）		`cummin(x)`	`=MIN($B$2:$B2)`	2,2,1,1,1
階差数列前進差分	注意）	`np.diff(x)`	`diff(x)`	`=B3-B2`	2,-3,2,2
第n階差		`np.diff(x,n=n)`		`=B3-B2`	2,-3,2,2
注意）リスト内包表記で可能。

線形代数の計算

\begin{eqnarray*}
&x &=& (x_i)^{n}_i &= (2,4,1,3,5) \\
&y &=& (y_i)^{n}_i &= (1,3,5,7,9)
\end{eqnarray*}

\begin{eqnarray*}
(x,y) &=& \sum_{i=1}^n x_iy_i &内積 \\
\|x\| = \sqrt{(x,x)} &=& \sqrt{\sum_{i=1}^n {x_i}^2} \quad &ノルム \\
\end{eqnarray*}

	Python	Python(Numpy)	R	VBA	EXCEL	結果
内積		`np.dot(v,w)` `np.sum(v*w)`	`sum(x*y)`		`=SUMPRODUCT(` `B2:B6,C2:C6)`	85
ノルム		`np.linalg.norm(v)` `np.sqrt(np.sum(v*v))`	`sqrt(sum(x*x))`		`=SQRT(` `SUMPRODUCT(` `B2:B6,B2:B6))`	7.416

注意）

プログラム全体

参考までに使ったプログラムの全体を示します。
Python、Rについては、長いので省略します。

Python

Python3

R

R

VBA

VBA

Sub test_vector()
Dim i As Integer

Debug.Print "v"
Dim v As Variant
v = Array(1, 2, 3, 4, 5)
Debug.Print LBound(v), UBound(v), UBound(v) - LBound(v) + 1
' 0             4             5
For i = LBound(v) To UBound(v)
    Debug.Print i, v(i)
Next i
' 0             1
' 1             2
' 2             3
' 3             4
' 4             5
Debug.Print v(3 - 1)
' 3

Debug.Print "s"
Dim s As Variant
s = Array("a", "b", "c", "d", "e")
Debug.Print LBound(s), UBound(s), UBound(s) - LBound(s) + 1
' 0             4             5
For i = LBound(s) To UBound(s)
    Debug.Print i, s(i)
Next i
' 0             a
' 1             b
' 2             c
' 3             d
' 4             e
Debug.Print s(3 - 1)
' c

Debug.Print "w"
Dim w(5) As Integer
Debug.Print LBound(w), UBound(w), UBound(w) - LBound(w) + 1
' 0             5             6
For i = LBound(w) To UBound(w)
    w(i) = i
Next i
For i = LBound(w) To UBound(w)
    Debug.Print i, w(i)
Next i
' 0             0
' 1             1
' 2             2
' 3             3
' 4             4
' 5             5

Debug.Print "x"
Dim x(2 To 5) As Integer
Debug.Print LBound(x), UBound(x), UBound(x) - LBound(x) + 1
' 2             5             4
For i = LBound(x) To UBound(x)
    x(i) = i
Next i
For i = LBound(x) To UBound(x)
    Debug.Print i, x(i)
Next i
' 2             2
' 3             3
' 4             4
' 5             5

Debug.Print "y"
Dim y() As Integer
ReDim y(5)
Debug.Print LBound(y), UBound(y), UBound(y) - LBound(y) + 1
' 0             5             6
For i = LBound(y) To UBound(y)
    y(i) = i
Next i
ReDim Preserve y(6) ' 要素の追加
Debug.Print LBound(y), UBound(y), UBound(y) - LBound(y) + 1
' 0             6             7
y(6) = 6
For i = LBound(y) To UBound(y)
    Debug.Print i, y(i)
Next i
' 0             0
' 1             1
' 2             2
' 3             3
' 4             4
' 5             5
' 6             6

Debug.Print "z"
Dim z As Variant
z = Range("B2:B6")
Debug.Print LBound(z, 1), UBound(z, 1), UBound(z, 1) - LBound(z, 1) + 1
' 1             5             5
For i = LBound(z, 1) To UBound(z, 1)
    Debug.Print i, z(i, 1)
Next i
' 1             2
' 2             4
' 3             1
' 4             3
' 5             5

End Sub

参考