VBAユーザがPython・Rを使ってみた：ベクトル

# はじめに

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


**目次**

- [ベクトル](#ベクトル)
   - [ベクトルの作成](#ベクトルの作成)
      - [規則性のあるベクトルの作成](#規則性のあるベクトルの作成)
   - [要素へのアクセス](#要素へのアクセス)
      - [要素の取得](#要素の取得)
      - [要素への代入](#要素への代入)
   - [ベクトルの属性](#ベクトルの属性)
      - [長さ](#長さ)
      - [要素名](#要素名)
   - [ベクトルの操作](#ベクトルの操作)
      - [要素の検索](#要素の検索)
      - [ソート等](#ソート等)
      - [集合演算](#集合演算)
      - [要素の置換](#要素の置換)
      - [ベクトルの結合と挿入](#ベクトルの結合と挿入)
   - [数ベクトル](#数ベクトル)
      - [数ベクトルの定義](#数ベクトルの定義)
      - [要素ごとの計算](#要素ごとの計算)
      - [統計量の計算](#統計量の計算)
      - [累積計算](#累積計算)
      - [線形代数の計算](#線形代数の計算)
   - [組み込み定数ベクトル](#組み込み定数ベクトル)
- [まとめ](#まとめ)
  - [一覧](#一覧)
  - [プログラム全体](#プログラム全体)


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

## ベクトルの作成

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

```Python: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: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 ステートメント](https://docs.microsoft.com/ja-jp/office/vba/language/reference/user-interface-help/option-base-statement)で配列のインデックスの下限を1に変更することもできます。

```VBA: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**

```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については下の[数ベクトル](#数ベクトル)の項を参照。

```Python: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: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:VBA
```

## 要素へのアクセス

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

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

```Python: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については下の[数ベクトル](#数ベクトル)の項を参照。

```Python: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: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 ステートメント](https://docs.microsoft.com/ja-jp/office/vba/language/reference/user-interface-help/option-base-statement)で配列のインデックスの下限を1に変更することもできます。

```VBA: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**

```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については下の[数ベクトル](#数ベクトル)の項を参照。

```Python: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: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: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**

```Python:Python3
v = list(range(1,5+1))
len(v)
# 5
```

**R**

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

**VBA**

```VBA:VBA
```


### 要素名

**Python**

```Python:Python3
```

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

```R: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:VBA
```


## ベクトルの操作

### 要素の検索

**Python**

```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については下の[数ベクトル](#数ベクトル)の項を参照。

```Python: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: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:VBA
```

### ソート等

**Python**

```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については下の数ベクトルの項を参照。

```Python: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: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:VBA
```


### 集合演算
```math
\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*}
```

```math
\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）型があります。

```Python: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: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:VBA
```



### 要素の置換

**Python**

```Python:Python3
```

**R**

```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:VBA
```

### ベクトルの結合と挿入

**Python**

```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: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:VBA
```

### ベクトルの要素の削除

**Python**

```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:R
```

**VBA**

```VBA:VBA
```



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

### 数ベクトルの定義

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

```Python: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:R
v <- c(1,2,3,4,5)
v
# [1] 1 2 3 4 5
```

**VBA**

```VBA:VBA
```

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

**Python**
Numpyのndarrayの要素ごとの演算に使える関数はここに挙げた以外にも多数用意されています（詳細は[こちら](https://numpy.org/doc/stable/reference/ufuncs.html#available-ufuncs)）。

```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])
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: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:VBA
```


### 統計量の計算
```math
\begin{eqnarray*}
&x &=& (x_i)^{n}_i &= (2,4,1,3,5) \\
&y &=& (y_i)^{n}_i &= (1,3,5,7,9)
\end{eqnarray*}
```

```math
\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**

```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: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:VBA
```

### 累積計算

**Python**

```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: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:VBA
```


### 線形代数の計算
```math
\begin{eqnarray*}
&x &=& (x_i)^{n}_i &= (2,4,1,3,5) \\
&y &=& (y_i)^{n}_i &= (1,3,5,7,9)
\end{eqnarray*}
```

```math
\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: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: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:VBA
```


## 組み込み定数ベクトル

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

```Python: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: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:VBA
```



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

***ベクトルの作成***

||Python|Python(Numpy)|R|VBA|EXCEL|結果|
|:--|:--|:--|:--|:--|:--|:--|
|ベクトル<br>の作成|`[1,2,3,4,5]`|`np.array([1,2,3,4,5])`|`c(1,2,3,4,5)`|`Array(`<br>`1, 2,`<br>` 3, 4,`<br>` 5)`|セル入力|1,2,3,4,5|
|1,...,n|`list(`<br>`range(1,10+1))`|`np.arange(1,10+1)`|`seq(10)`||`=1つ前+1`|1,2,...,10|
|連続する<br>整数列|`list(`<br>`range(1,10+1,1))`|`np.arange(1,10+1,1)`|`1:10`<br>`seq(1,10)`||`=1つ前+1`|1,2,...,10|
|連続する<br>整数列|`list(`<br>`range(10,1-1,-1))`|`np.arange(10,1-1,-1)`|`10:1`<br>`seq(1,10,-1)`||`=1つ前-1`|10,9,...,1|
|等差数列|`list(`<br>`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,`<br>`num=5+1)`|`seq(0,10,`<br>`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を<br>繰り返し|`[0]*10`|`np.zeros(10)`|`numeric(10)`<br>`rep(0,10)`||`=0`|0,0,...,0|
|1,1,2,<br>1,2,3,...|||`sequence(1:3)`<br>`c(seq(1),seq(2),`<br>`seq(3))`<br>`c(1:1,1:2,1:3)`|||1,1,2,1,2,3|
|重複削除|`list(set(`<br>`[1,2,2,3,3,3]))`||`unique(`<br>`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) `<br>`- LBound(v, 1)`<br>` + 1`||
|要素の型|||`typeof(v)`<br>`mode(v)`|||


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

||Python|Python(Numpy)|R|VBA|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)]`<br>`v[-c(1,3,5)]`|||2,4,6,7<br>,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|VBA|EXCEL|
|:--|:--|:--|:--|:--|:--|
|条件に合う要素番号||`np.argwhere(v==1)`|`which(v==1)`<br>`which(v<50)`||`=MATCH(1, ,0)`<br>　|
|条件に合う要素||`v[v<5]`|`v[which(v<5)]`<br>`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|VBA|EXCEL|結果|
|:--|:--|:--|:--|:--|:--|:--|
|逆順|`v[::-1]`<br>`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)`<br>`v.sort()`|`np.sort(v)`|`sort(v)`<br>`v[order(v)]`|||1,2,3,4,5|
|降順ソート|`sorted(v,`<br>`reverse=True)`<br>`v.sort(`<br>`reverse=True)`|`np.sort(v)[::-1]`|`rev(sort(v))`<br>`sort(v,`<br>`decreasing=T)`<br>`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,`<br>`[0,25,50,75,100])`<br>`np.quantile(v,`<br>`[0,0.25,0.5,0.75,1])`|`quantile(v)`||`=QUARTILE( ,n)`<br>n： 0,1,2,3,4|第1四分位:2,<br>第3四分位:4|
|summary|||`summary(v)`||||

***集合演算***

```math
\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*}
```

```math
\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|VBA|EXCEL|結果|
|:--|:--|:--|:--|:--|:--|
|重複削除|`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)`<br>`a %in% A`|||True|
注意）Pythonではset型を使う。Rではベクトルを集合とみなして集合演算ができる。

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

||Python|R|VBA|EXCEL|
|:--|:--|:--|:--|:--|
|置換||`replace(v,要素,w)`|||
|結合|`u + v + w`|`c(u,v,w)`<br>`append(u,v)`|||
|挿入||`append(u,v,after=n)`|||
|挿入|`v.append(3)`|`append(v,3)`|||
|削除|`v.remove(3)`||||

***要素ごとの計算***

||Python|Python(Numpy)|R|VBA|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)`|

***統計量の計算***

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

```math
\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|VBA|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)`<br>`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)`<br>`=VARP(B2:B6)`|2|
|不偏分散||`np.var(x,ddof=1)`|`var(x)`||`=VAR.S(B2:B6)`<br>`=VAR(B2:B6)`|2.5|
|標準偏差||`np.std(x)`|`sd(x)*sqrt(`<br>`var(x)*(n-1)/n)`||`=STDEV.P(B2:B6)`<br>`=STDEVP(B2:B6)`|1.414|
|不偏標準偏差||`np.std(x,ddof=1)`|`sd(x)`||`=STDEV.S(B2:B6)`<br>`=STDEV(B2:B6)`|1.581|
|共分散|||`cov(x,y)*(n-1)/n`||`=COVARIANCE.P(`<br>`B2:B6,C2:C6)`<br>`=COVAR(`<br>`B2:B6,C2:C6)`|2|
|不偏共分散|||`cov(x,y)`||`=COVARIANCE.S(`<br>`B2:B6,C2:C6)`|2.5|
|相関係数|||`cor(x,y)`||`=CORREL(`<br>`B2:B6,C2:C6)`|0.5|
|分散共分散行列||`np.cov(x,y)`|||||
|相関係数行列||`np.corrcoef(x,y)`|||||
|summary|||`summary(v)`|||

***累積計算***

||Python|Python(Numpy)|R|VBA|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|
|階差数列<br>前進差分|注意）|`np.diff(x)`|`diff(x)`||`=B3-B2`|2,-3,2,2|
|第n階差||`np.diff(x,n=n)`|||`=B3-B2`|2,-3,2,2|
注意）リスト内包表記で可能。

***線形代数の計算***

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

```math
\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)`<br>`np.sum(v*w)`|`sum(x*y)`||`=SUMPRODUCT(`<br>`B2:B6,C2:C6)`|85|
|ノルム||`np.linalg.norm(v)`<br>`np.sqrt(np.sum(v*v))`|`sqrt(sum(x*x))`||`=SQRT(`<br>`SUMPRODUCT(`<br>`B2:B6,B2:B6))`|7.416|


注意）



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

**Python**

```Python:Python3
```

**R**

```R:R
```

**VBA**

```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
```


# 参考
- Python
   - [Python チュートリアル](https://docs.python.org/ja/3/tutorial/index.html)
      - [3.1.3. リスト型 (list)](https://docs.python.org/ja/3/tutorial/introduction.html#lists)
      - [5.1. リスト型についてもう少し](https://docs.python.org/ja/3/tutorial/datastructures.html)
      - [5.3. タプルとシーケンス](https://docs.python.org/ja/3/tutorial/datastructures.html#tuples-and-sequences)
      - [5.4. 集合型](https://docs.python.org/ja/3/tutorial/datastructures.html#sets)
   - [Chainer チュートリアル](https://tutorials.chainer.org/ja/tutorial.html)
      - [2. Python 入門](https://tutorials.chainer.org/ja/02_Basics_of_Python.html#Python-入門)
      - [2.6. 複合データ型](https://tutorials.chainer.org/ja/02_Basics_of_Python.html#複合データ型)
      - [2.6.1. リスト](https://tutorials.chainer.org/ja/02_Basics_of_Python.html#リスト)
      - [2.6.2. タプル](https://tutorials.chainer.org/ja/02_Basics_of_Python.html#タプル)
      - [8. NumPy 入門](https://tutorials.chainer.org/ja/08_Introduction_to_NumPy.html)
   - [NumPy Reference](https://numpy.org/doc/stable/reference/)
      - [Array creation routines](https://numpy.org/doc/stable/reference/routines.array-creation.html)
      - [Array manipulation routines](https://numpy.org/doc/stable/reference/routines.array-manipulation.html)
      - [Sorting, searching, and counting](https://numpy.org/doc/stable/reference/routines.sort.html)
      - [Universal functions](https://numpy.org/doc/stable/reference/ufuncs.html)
      - [Mathematical functions](https://numpy.org/doc/stable/reference/routines.math.html)
      - [Linear algebra](https://numpy.org/doc/stable/reference/routines.linalg.html)
      - [Statistics](https://numpy.org/doc/stable/reference/routines.statistics.html)
- R
   - [RjpWiki](http://www.okadajp.org/RWiki/)
      - [Rの組み込み定数文字ベクトル、定数値](http://www.okadajp.org/RWiki/?Rの組み込み定数文字ベクトル、定数値)
      - [ベクトルTips大全](http://www.okadajp.org/RWiki/?ベクトルTips大全)
   - [R-Tips](http://cse.naro.affrc.go.jp/takezawa/r-tips/r.html)
      - [12. ベクトルの作成](http://cse.naro.affrc.go.jp/takezawa/r-tips/r/12.html)
      - [13. ベクトル要素へのアクセス](http://cse.naro.affrc.go.jp/takezawa/r-tips/r/13.html)
      - [14. ベクトル計算](http://cse.naro.affrc.go.jp/takezawa/r-tips/r/14.html)
      - [15. ベクトル要素の置換・結合・挿入](http://cse.naro.affrc.go.jp/takezawa/r-tips/r/15.html)
      - [16. 種々のベクトル](http://cse.naro.affrc.go.jp/takezawa/r-tips/r/16.html)
      - [17. 文字列を操作する](http://cse.naro.affrc.go.jp/takezawa/r-tips/r/17.html)
      - [18. NULL，NA，NaN，Infの操作](http://cse.naro.affrc.go.jp/takezawa/r-tips/r/18.html)
      - [23. リスト](http://cse.naro.affrc.go.jp/takezawa/r-tips/r/23.html)
      - [25. データ型とデータ構造](http://cse.naro.affrc.go.jp/takezawa/r-tips/r/25.html)
      - [26. names 属性と要素のラベル](http://cse.naro.affrc.go.jp/takezawa/r-tips/r/26.html)
- VBA
   - [Office VBA リファレンス](https://docs.microsoft.com/ja-jp/office/vba/api/overview/)
      - [配列キーワードの概要](https://docs.microsoft.com/ja-jp/office/vba/language/reference/user-interface-help/arrays-keyword-summary)
      - [Option Base ステートメント](https://docs.microsoft.com/ja-jp/office/vba/language/reference/user-interface-help/option-base-statement)
      - [配列](https://docs.microsoft.com/ja-jp/office/vba/language/glossary/vbe-glossary#array)