Pythonの数値計算ライブラリ「Numpy」の配列（ndarray）操作一覧

　Pythonの数値計算ライブラリ「Numpy」が提供するN次元配列オブジェクト（以下、ndarray）の操作方法を整理する。
　Pythonはデータ型のサポートがない為に計算が低速であり、大量のデータを使って計算する際にはndarrayを使う事が標準的です。

# 前提

``` import numpy as np ```

# A. 配列生成

ndarrayを生成する。

## 【`array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)`】
* リストからndarrayを作成する。
  * object：元となるリスト（又はそのように扱う事ができるもの）
  * dtype：要素のデータ型。未指定の場合は要素に基づいて自動選択。（参考：[NumPyのデータ型dtype一覧とastypeによる変換（キャスト） | note.nkmk.me](https://note.nkmk.me/python-numpy-dtype-astype/)）

```python
y = np.array([1,2,3])
X = np.array([[1,2,3], [4,5,6]], dtype=np.int64)
```

## 【`zeros(shape, dtype=float, order='C')`】
* 各要素が0で埋められたndarrayを生成する。
  * shape：各次元の要素数（整数又は整数のタプル）

```python
y = np.zeros(3)
# array([0., 0., 0.])

X = np.zeros((2,3))
# array([[0., 0., 0.],
#       [0., 0., 0.]])
```

## 【`ones(shape, dtype=None, order='C')`】
* 各要素が1で埋めれらたndarrayを生成する。

```python
y = np.ones(3)
# array([1., 1., 1.])

X = np.ones((2,3))
# array([[1., 1., 1.],
#       [1., 1., 1.]])
```

## 【`empty(shape, dtype=None, order='C')`】
* 各要素が初期化されていないndarrayを生成する。

```python
y = np.empty(3)
# array([0.39215686, 0.70980392, 0.80392157])

X = np.empty((2,3))
# array([[2.6885677e-316, 0.0000000e+000, 0.0000000e+000],
#       [0.0000000e+000, 0.0000000e+000, 0.0000000e+000]])
```

## 【`identity(n, dtype=None)`】
* 単位行列となるndarrayを生成する。

```python
X = np.identity(3)
# array([[1., 0., 0.],
#       [0., 1., 0.],
#       [0., 0., 1.]])
```

## 【`arange([start,] stop[, step,], dtype=None)`】
* 等差数列となるndarrayを生成する。
  * start：等差数列の開始値
  * stop：等差数列の終了の基準値（指定した値以上の値は数列に含まれない）
  * step：差

```python
y = np.arange(5)
# array([0, 1, 2, 3, 4])

y = np.arange(2,5)
# array([2, 3, 4])

y = np.arange(5,2,-1)
# array([5, 4, 3])  
```

## 【`linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)`】
* 指定範囲を分割した等差数列となるndarrayを生成する。
  * start：等差数列の開始値
  * stop：等差数列の終了値
  * step：分割値（配列の要素数）

```python
y = np.linspace(2,10,3)
# array([ 2.,  6., 10.])

y = np.linspace(2,10,5)
# array([ 2.,  4.,  6.,  8., 10.])
```

## 【`unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)`】
* ソートした上で重複を削除したndarrayを生成する。

```python
y = np.unique(['C', 'E', 'C', 'A', 'B', 'E', 'D', 'C'])
# array(['A', 'B', 'C', 'D', 'E'], dtype='<U1')
```

# B. 配列要素取得

　ndarrayの要素は、[Pythonでのリスト要素の取得](https://qiita.com/nezuq/items/d66d330312cba59731c4)と同じ方法で取得できる。
　ただし、多次元配列の場合は指定方法が変わるので注意する。

```python
X = [[1,2,3],[4,5,6]]
print(X[1][2])
# 6

X_numpy = np.array(X)
print(X_numpy[1,2])
# 6 
```

又、通常の取得方法とは別に次の方法でも取得できる。

## 1. インデックスの配列で取得する。

```python
X = np.array([[1,2,3],[4,5,6]])

print(X[[0,1,-1]])
# [[1 2 3],
#  [4 5 6],
#  [4 5 6]]

print(X[[0,1,-1], 0])
# [1, 4, 4]

print(X[[0,1,-1], ::-1])
# [[3 2 1],
#  [6 5 4],
#  [6 5 4]]

print(X[[0,1,-1],[1,0,-1]])
# [2, 4, 6]
"""
※この指定は、次と同じ結果になっている。
np.array([X[0,1], X[1,0], X[-1,-1]])
"""
```

## 2. 条件式で取得する。

```python
X = np.array([[1,2,3],[4,5,6]])

print(X > 4)
#  [[False, False, False],
#  [False,  True,  True]]

print(np.where(X > 4))
# (array([1, 1]), array([1, 2]))

print(X[X > 4])
# [5, 6]

print(X[np.where(X > 4)])
# [5, 6]
```

# C. 配列情報の取得

ndarrayの情報を取得する。

## 【`shape`】
* 各次元の要素数を取得する。

```python
X = np.array([[1,2,3], [4,5,6]])
X.shape
# (2, 3)
```

## 【`dtype`】
* データ型を取得する。

```python
X = np.array([[1,2,3], [4,5,6]])
X.dtype
# dtype('int64')
```

## 【`ndim`】
* 次元数を取得する。

```python
X = np.array([[1,2,3], [4,5,6]])
X.ndim
# 2
```

## 【`size`】
* 要素数を取得する。

```python
X = np.array([[1,2,3], [4,5,6]])
X.size
# 6
```

# D. 配列操作

ndarrayを操作する。

## 【`<ndarray>.flatten(order='C')`】
* 一次元配列にする。

```python
X = np.array([[1,2,3], [4,5,6]])
print(X.flatten())
# [1, 2, 3, 4, 5, 6]
```

## 【`<ndarray>.reshape(shape, order='C')`】
* 配列の形状（次元数および各次元の要素数）を変える。

```python
X = np.array([1,2,3,4,5,6])
print(X.reshape((3,2)))
# [[1, 2],
#  [3, 4],
#  [5, 6]]
```

## 【`sort(a, axis=-1, kind='quicksort', order=None)`】
* 並び替える。（対象をコピーし、コピーを並べ替えて返す）
  * axis：ソートする次元

```python
X1 = np.array([[5,4,6], [3,1,2]])
X2 = np.sort(X1)
print(X1)
# [[5 4 6]
#  [3 1 2]]
print(X2)
# [[4 5 6]
#  [1 2 3]]

X3 = np.sort(X1, axis=0)
print(X3)
# [[3 1 2]
# [5 4 6]]
```

## 【`<ndarray>.sort(axis=-1, kind='quicksort', order=None)`】
* 並び替える。（対象を並び替える）
  * axis：ソートする次元

```python
X = np.array([[5,4,6], [3,1,2]])

X.sort()
print(X)
# [4 5 6]
# [1 2 3]]

X.sort(axis=0)
print(X)
# [[3 1 2]
# [5 4 6]]
```

## 【`<ndarray>.argsort(axis=-1, kind='quicksort', order=None)`】
* 並び替えた時のインデックスを取得する。

```python
X = np.array([[5,4,6], [3,1,2]])

idxs = X.argsort()
print(idxs)
# [[1 0 2]
#  [1 2 0]]

idxs = X.argsort(axis=0)
print(idxs)
# [[1 1 1]
# [0 0 0]]
```

## 【`<ndarray>.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)`】
* ndarrayのデータ型を変換する。

```python
X = np.array([[1,2,3], [4,5,6]])
print(X.dtype)
# int64
print(X)
# [[1 2 3]
# [4 5 6]]

X2 = X.astype(np.float64)
print(X2.dtype)
# float64
print(X2)
# [[1. 2. 3.]
# [4. 5. 6.]]
```

# E. 行列操作

ndarrayで行列操作を行う。

## 【`<ndarray>.T`】
* 転置

```python
X = np.array([[1,2,3], [4,5,6]])
print(X.T)
# [[1, 4],
#  [2, 5],
#  [3, 6]]
```

## 【`numpy.dot`】【`<ndarray>.dot`】
* 内積

```python
X1 = np.array([[1, 2, 3], [4, 5, 6]])
X2 = np.array([[10, 20], [100, 200], [1000, 2000]])
print(np.dot(X1, X2))
# [[ 3210  6420]
#  [ 6540 13080]]

print(X1.dot(X2))
# [[ 3210  6420]
#  [ 6540 13080]]
```

## 【`numpy.trace`】【`<ndarray>.trace`】
* 対角成分の合計

```python
X = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(np.trace(X))
# 15

print(X.trace())
# 15
```

## 【`numpy.linalg.det`】
* 行列式

```python
X1 = np.array([[3., 2.], [5., 4.]])
print(np.linalg.det(X1))
# 2.0000000000000013
```

## 【`numpy.linalg.eig`】
* 固有値・固有ベクトル

```python
X = np.array([[2, 0], [0, 0.25]])
print(np.linalg.eig(X))
# (array([2.  , 0.25]), array([[1., 0.], [0., 1.]]))
```

## 【`numpy.linalg.svd`】
* 特異値分解

```python
X = np.array([[2, 0], [0, 0.25], [0, 1]])
print(np.linalg.svd(X))
# (array([[ 1.,  0.        ,  0.        ],
#         [ 0., -0.24253563, -0.9701425 ],
#         [ 0., -0.9701425 ,  0.24253563]]), 
#  array([2., 1.03077641]), 
#  array([[ 1.,  0.],
#         [-0., -1.]]))
```

## 【`numpy.linalg.inv`】
* 逆行列

```python
X = np.array([[1, 1], [1, -1]])
print(np.linalg.inv(X))
# [[ 0.5  0.5]
#  [ 0.5 -0.5]]
```

## 【`numpy.linalg.pinv`】
* ムーア・ペンローズの擬似逆行列

```python
X = np.array([[1, 1], [1, -1], [1, 0]])
print(np.linalg.pinv(X))
# [[ 0.33333333  0.33333333  0.33333333]
#  [ 0.5        -0.5         0.        ]]
```

## 【`numpy.linalg.qr`】 
* QR分解

```python
X = np.array([[1, 2], [3, 4], [5, 6]])
print(np.linalg.qr(X))
# (array([[-0.16903085,  0.89708523],
#         [-0.50709255,  0.27602622],
#         [-0.84515425, -0.34503278]]),
#  array([[-5.91607978, -7.43735744],
#         [ 0.        ,  0.82807867]]))
```

# F. 算術演算

二つのndarray同士で、算術演算をする。

## 【`add`】
* 足し算（加算）

```python
a = np.array([[1, 2, 3], [4, 5, 6]])

print(np.add(a, 10))
# [[11 12 13]
#  [14 15 16]]
print(a + 10)
# [[11 12 13]
#  [14 15 16]]

print(np.add(a, [10, 20, 30]))
# [[11 22 33]
#  [14 25 36]]
print(a + [10, 20, 30])
# [[11 22 33]
#  [14 25 36]]

print(np.add(a, np.array([[10, 20, 30], [40, 50, 60]])))
# [[11 22 33]
#  [44 55 66]]
print(a + np.array([[10, 20, 30], [40, 50, 60]]))
# [[11 22 33]
#  [44 55 66]]
```

## 【`subtract`】
* 引き算（減算）

```python
a = np.array([[11, 22, 33], [44, 55, 66]])

print(np.subtract(a, 10))
# [[ 1 12 23]
#  [34 45 56]]
print(a - 10)
# [[ 1 12 23]
#  [34 45 56]]

print(np.subtract(a, [10, 20, 30]))
# [[ 1  2  3]
#  [34 35 36]]
print(a - [10, 20, 30])
# [[ 1  2  3]
#  [34 35 36]]

print(np.subtract(a, np.array([[10, 20, 30], [40, 50, 60]])))
# [[1 2 3]
#  [4 5 6]] 
print(a - np.array([[10, 20, 30], [40, 50, 60]]))
# [[1 2 3]
#  [4 5 6]]
```

## 【`multiply`】
* 掛け算（乗算）

```python
a = np.array([[1, 2, 3], [4, 5, 6]])

print(np.multiply(a, 10))
# [[10 20 30]
#  [40 50 60]]
print(a * 10)
# [[10 20 30]
#  [40 50 60]]

print(np.multiply(a, [10, 20, 30]))
# [[ 10  40  90]
#  [ 40 100 180]]
print(a * [10, 20, 30])
# [[ 10  40  90]
#  [ 40 100 180]]

print(np.multiply(a, np.array([[10, 20, 30], [40, 50, 60]])))
# [[ 10  40  90]
#  [160 250 360]]
print(a * np.array([[10, 20, 30], [40, 50, 60]]))
# [[ 10  40  90]
#  [160 250 360]]
```

## 【`divide`】
* 割り算（除算）

```python
a = np.array([[10, 20, 30], [40, 50, 60]])

print(np.divide(a, 10))
# [[1. 2. 3.]
#  [4. 5. 6.]]
print(a / 10)
# [[1. 2. 3.]
#  [4. 5. 6.]]

print(np.divide(a, [10, 20, 30]))
# [[1.  1.  1. ]
#  [4.  2.5 2. ]]
print(a / [10, 20, 30])
# [[1.  1.  1. ]
#  [4.  2.5 2. ]]

print(np.divide(a, np.array([[10, 20, 30], [40, 50, 60]])))
# [[1. 1. 1.]
#  [1. 1. 1.]]
print(a / np.array([[10, 20, 30], [40, 50, 60]]))
# [[1. 1. 1.]
#  [1. 1. 1.]]
```

## 【`floor_divide`】
* 割り算の商

```python
a = np.array([[22, 33, 44], [45, 67, 89]])

print(np.floor_divide(a, 2))
# [[11 16 22]
#  [22 33 44]]
print(a // 2)
# [[11 16 22]
#  [22 33 44]]

print(np.floor_divide(a, [2, 3, 4]))
# [[11 11 11]
#  [22 22 22]]
print(a // [2, 3, 4])
# [[11 11 11]
#  [22 22 22]]

print(np.floor_divide(a, np.array([[2, 3, 4], [4, 6, 8]])))
# [[11 11 11]
#  [11 11 11]]
print(a // np.array([[[2, 3, 4], [4, 6, 8]]]))
# [[11 11 11]
#  [11 11 11]]
```

## 【`mod`】
* 割り算の余り

```python
a = np.array([[22, 33, 44], [45, 67, 89]])

print(np.mod(a, 2))
# [[0 1 0]
#  [1 1 1]]
print(a % 2)
# [[0 1 0]
#  [1 1 1]]

print(np.mod(a, [2, 3, 4]))
# [[0 0 0]
#  [1 1 1]]
print(a % [2, 3, 4])
# [[0 0 0]
#  [1 1 1]]

print(np.mod(a, np.array([[2, 3, 4], [4, 6, 8]])))
# [[0 0 0]
#  [1 1 1]]
print(a % np.array([[[2, 3, 4], [4, 6, 8]]]))
# [[0 0 0]
#  [1 1 1]]
```

## 【`power`】
* 累乗

```python
a = np.array([[1, 2, 3], [4, 5, 6]])

print(np.power(a, 2))
# [[ 1  4  9]
#  [16 25 36]]
print(a ** 2)
# [[ 1  4  9]
#  [16 25 36]]

print(np.power(a, [2, 3, 4]))
# [[   1    8   81]
#  [  16  125 1296]]
print(a ** [2, 3, 4])
# [[   1    8   81]
#  [  16  125 1296]]

print(np.power(a, np.array([[2, 3, 4], [1/2, 1/3, 1/4]])))
# [[ 1.          8.         81.        ]
#  [ 2.          1.70997595  1.56508458]]
print(a ** np.array([[2, 3, 4], [1/2, 1/3, 1/4]]))
# [[ 1.          8.         81.        ]
#  [ 2.          1.70997595  1.56508458]]
```

# G. 比較演算

二つのndarrayを比較する。

## 【`greater`】
* より大きい

```python
a1 = np.array([10, 10, 10, 10, 10])
a2 = np.array([9, 9.9, 10, 10.1, 11])

print(np.greater(a1, a2))
# [ True  True False False False]
print(a1 > a2)
# [ True  True False False False]
```

## 【`greater_equal`】
* 以上

```python
a1 = np.array([10, 10, 10, 10, 10])
a2 = np.array([9, 9.9, 10, 10.1, 11])

print(np.greater_equal(a1, a2))
# [ True  True True False False]
print(a1 >= a2)
# [ True  True True False False]
```

## 【`less`】
* より小さい

```python
a1 = np.array([10, 10, 10, 10, 10])
a2 = np.array([9, 9.9, 10, 10.1, 11])

print(np.less(a1, a2))
# [False False False  True  True]
print(a1 < a2)
# [False False False  True  True]
```

## 【`less_equal`】
* 以下

```python
a1 = np.array([10, 10, 10, 10, 10])
a2 = np.array([9, 9.9, 10, 10.1, 11])

print(np.less_equal(a1, a2))
# [False False  True  True  True]
print(a1 <= a2)
# [False False  True  True  True]
```

## 【`equal`】
* 等しい

```python
a1 = np.array([10, 10, 10, 10, 10])
a2 = np.array([9, 9.9, 10, 10.1, 11])

print(np.equal(a1, a2))
# [False False  True False False]
print(a1 == a2)
# [False False  True False False]
```

## 【`not_equal`】
* 等しくない

```python
a1 = np.array([10, 10, 10, 10, 10])
a2 = np.array([9, 9.9, 10, 10.1, 11])

print(np.not_equal(a1, a2))
# [ True  True False  True  True]
print(a1 != a2)
# [ True  True False  True  True]
```

# H. 論理演算

二つのndarrayを論理演算する。

## 【`logical_and`】
* AND

```python
a1 = np.array([True, False, True, False])
a2 = np.array([True, False, False, True])

print(np.logical_and(a1, a2))
# [ True False False False]
```

## 【`logical_or`】
* OR

```python
a1 = np.array([True, False, True, False])
a2 = np.array([True, False, False, True])

print(np.logical_or(a1, a2))
# [ True False  True  True]
```

## 【`logical_xor`】
* XOR

```python
a1 = np.array([True, False, True, False])
a2 = np.array([True, False, False, True])

print(np.logical_xor(a1, a2))
# [False False  True  True]
```

## 【`logical_not`】
* NOT

```python
a = np.array([True, False, True, False])

print(np.logical_not(a))
# [False  True False  True]
```

## 【`<ndarray>.any()`】
* いずれかの要素がTrue

```python
a1 = np.array([0, 1, 0, 0])
print(a1.any())
# True

a2 = np.array([1, 1, 1, 1])
print(a2.any())
# True

a3 = np.array([0, 0, 0, 0])
print(a3.any())
# False
```

## 【`<ndarray>.all()`】
* すべての要素がTrue

```python
a1 = np.array([0, 1, 0, 0])
print(a1.all())
# False

a2 = np.array([1, 1, 1, 1])
print(a2.all())
# True

a3 = np.array([0, 0, 0, 0])
print(a3.all())
# False
```

# I. 集合演算

ndarrayでの集合演算をする。
※集合演算自体はPythonのsetでも行える。参考：[Pythonの集合演算](https://qiita.com/nezuq/items/4ea66c1bf6627eab2345)

## 【`union1d(ar1, ar2)`】
* 和集合（OR）

```python
X = np.unique([1,2,3,4,5,6])
Y = np.unique([4,5,6,7,8,9])

Z = np.union1d(X,Y)
print(Z)
# [1 2 3 4 5 6 7 8 9]
```

## 【`intersect1d(ar1, ar2)`】
* 積集合（AND）

```python
X = np.unique([1,2,3,4,5,6])
Y = np.unique([4,5,6,7,8,9])

Z = np.intersect1d(X,Y)
print(Z)
# [4 5 6]
```

## 【`setxor1d(ar1, ar2)`】
* 対称差（XOR）

```python
X = np.unique([1,2,3,4,5,6])
Y = np.unique([4,5,6,7,8,9])

Z = np.setxor1d(X,Y)
print(Z)
# [1 2 3 7 8 9]
```

## 【`setdiff1d(ar1, ar2)`】
* 差集合

```python
X = np.unique([1,2,3,4,5,6])
Y = np.unique([4,5,6,7,8,9])

Z = np.setdiff1d(X,Y)
print(Z)
# [1 2 3]
```

## 【`in1d(ar1, ar2)`】
* 前者の集合の各要素が後者に含まれるかの判定

```python
X = np.unique([1,2,3,4,5])
Y = np.unique([1,2,3])

Z = np.in1d(X,Y)
print(Z)
# [ True  True  True False False]
```

# J. 最大値・最小値・符号抽出

ndarrayの最大値・最小値・符号を抽出する。

## 【`maximum`】
* 最大値（2つのndarrayを比較し、大きい方を取得）
  * 片方の要素がNaNの場合は、NaNを取得。

```python
a1 = np.array([4, 2, np.nan])
a2 = np.array([3, 6, 5])

print(np.maximum(a1, a2))
# [ 4.  6. nan]
```

## 【`fmax`】
* 最大値（2つのndarrayを比較し、大きい方を取得）
  * 片方の要素がNaNの場合は、もう片方を取得。

```python
a1 = np.array([4, 2, np.nan])
a2 = np.array([3, 6, 5])

print(np.fmax(a1, a2))
# [4. 6. 5.]
```

## 【`minimum`】
* 最小値（2つのndarrayを比較し、小さい方を取得）
  * 片方の要素がNaNの場合は、NaNを取得。

```python
a1 = np.array([4, 2, np.nan])
a2 = np.array([3, 6, 5])

print(np.minimum(a1, a2))
# [ 3.  2. nan]
```

## 【`fmin`】
* 最小値（2つのndarrayを比較し、小さい方を取得）
  * 片方の要素がNaNの場合は、もう片方を取得。

```python
a1 = np.array([4, 2, np.nan])
a2 = np.array([3, 6, 5])

print(np.fmin(a1, a2))
# [3. 2. 5.]
```

## 【`copysign`】
* 1つ目のndarrayに、2つ目のndarrayで対応する要素の符号を当てる。

```python
a1 = np.array([1, 2, 3, 4, 5])
a2 = np.array([0, -1, 1, 2, -2])

print(np.copysign(a1, a2))
# [ 1. -2.  3.  4. -5.]
```

# K. 切り上げ・切り捨て・四捨五入

ndarrayの各値で、小数点以下の値を処理する。

## 【`ceil(ndarray)`】
* 切り上げ

```python
y = np.array([-5.6, -5.5, -5.4, 0, 5.4, 5.5, 5.6])

z = np.ceil(y)
print(z)
# [-5. -5. -5.  0.  6.  6.  6.]
```

## 【`floor(ndarray)`】
* 切り捨て

```python
y = np.array([-5.6, -5.5, -5.4, 0, 5.4, 5.5, 5.6])

z = np.floor(y)
print(z)
# [-6. -6. -6.  0.  5.  5.  5.]
```

## 【`rint(ndarray)`】
* 四捨五入

```python
y = np.array([-5.6, -5.5, -5.4, 0, 5.4, 5.5, 5.6])

z = np.rint(y)
print(z)
# [-6. -6. -5.  0.  5.  6.  6.]
```

## 【`modf(ndarray)`】
* 整数部と小数部の分割

```python
y = np.array([-3.6, -2.5, -1.4, 0, 1.4, 2.5, 3.6])

z = np.modf(y)
print(z)
# (array([-0.6, -0.5, -0.4,  0. ,  0.4,  0.5,  0.6]), array([-3., -2., -1.,  0.,  1.,  2.,  3.]))
```

# L. 二乗・平方根・絶対値

ndarrayの各値で、二乗・平方根・絶対値を算出する。

## 【`square(ndarray)`】
* 二乗

```python
y = np.arange(1,6)

z = np.square(y)
print(z)
# [ 1  4  9 16 25]

z = y ** 2
print(z)
# [ 1  4  9 16 25]
```

## 【`sqrt(ndarray)`】
* 平方根

```python
y = np.array([1,4,9,16,25])

z = np.sqrt(y)
print(z)
# [1. 2. 3. 4. 5.]

z = y ** 0.5
print(z)
# [1. 2. 3. 4. 5.]
```

## 【`abs(ndarray)`】
* 絶対値

```python
y = np.array([-1,-2,3,4,5j])

z = np.abs(y)
print(z)
# [1, 2, 3, 4, 5]
```

## 【`fabs(ndarray)`】
* 絶対値（虚数・複素数不可だが、absより高速）

```python
y = np.array([-1,-2,3,4,-5])

z = np.fabs(y)
print(z)
# [1, 2, 3, 4, 5]
```

# M. 指数・対数関数

ndarrayの各値で、指数・対数を算出する。

## 【`exp(ndarray)`】
* 指数

```python
y = np.arange(1,6)

z = np.exp(y)
print(z)
# [  2.71828183   7.3890561   20.08553692  54.59815003 148.4131591 ]

print(np.e)
# 2.718281828459045
```

## 【`log(ndarray)`】
* 自然対数

```python
y = np.e ** np.array([1, 2, 3, 4, 5])

z = np.log(y)
print(z)
# [1. 2. 3. 4. 5.]
```

## 【`log10(ndarray)`】
* 常用対数

```python
y = 10 ** np.array([1, 2, 3, 4, 5])

z = np.log10(y)
print(z)
# [1. 2. 3. 4. 5.]
```

## 【`log2(ndarray)`】
* 二進対数

```python
y = 2 ** np.array([1, 2, 3, 4, 5])

z = np.log2(y)
print(z)
# [1. 2. 3. 4. 5.]
```

# N. 三角関数

ndarrayの各値に、三角関数を適用する。

## 【`sin(ndarray)`】
* 正弦

```python
y = np.linspace(-1, 1, 5)  * np.pi

print(np.sin(y))
# [-1.2246468e-16 -1.0000000e+00  0.0000000e+00  1.0000000e+00 1.2246468e-16]
```

## 【`cos(ndarray)`】
* 余弦

```python
y = np.linspace(-1, 1, 5)  * np.pi

print(np.cos(y))
# [-1.000000e+00  6.123234e-17  1.000000e+00  6.123234e-17 -1.000000e+00]
```

## 【`tan(ndarray)`】
* 正接

```python
y = np.linspace(-1, 1, 5)  * np.pi

print(np.tan(y))
# [ 1.22464680e-16 -1.63312394e+16  0.00000000e+00  1.63312394e+16 -1.22464680e-16]
```

# O. 双曲線関数

ndarrayの各値に、双曲線関数を適用する。

## 【`sinh(ndarray)`】
* 双曲線正弦

```python
y = np.array([-np.inf, -2, -1, 0, 1, 2, np.inf])

print(np.sinh(y))
# [-inf -3.62686041 -1.17520119  0. 1.17520119  3.62686041 inf]
```

## 【`cosh(ndarray)`】
* 双曲線余弦

```python
y = np.array([-np.inf, -2, -1, 0, 1, 2, np.inf])

print(np.cosh(y))
# [inf 3.76219569 1.54308063 1. 1.54308063 3.76219569 inf]
```

## 【`tanh(ndarray)`】
* 双曲線正接

```python
y = np.array([-np.inf, -2, -1, 0, 1, 2, np.inf])

print(np.tanh(y))
# [-1. -0.96402758 -0.76159416  0. 0.76159416  0.96402758 1.]
```

# P. 逆三角関数

ndarrayの各値に、逆三角関数を適用する。

## 【`arcsin(ndarray)`】
* 逆正弦

```python
y = np.linspace(-1, 1, 5)

print(np.arcsin(y))
# [-1.57079633 -0.52359878  0. 0.52359878  1.57079633]
```

## 【`arccos(ndarray)`】
* 逆余弦

```python
y = np.linspace(-1, 1, 5)

print(np.arccos(y))
# [3.14159265 2.0943951  1.57079633 1.04719755 0.]
```

## 【`arctan(ndarray)`】
* 逆正接

```python
y = np.linspace(-1, 1, 5)

print(np.arctan(y))
# [-0.78539816 -0.46364761  0. 0.46364761  0.78539816]
```

# Q. 逆双曲線関数

ndarrayの各値に、逆双曲線関数を適用する。

## 【`arcsinh(ndarray)`】
* 逆双曲線正弦

```python
y = np.array([-np.inf, -3.62686041, -1.17520119,  0., 1.17520119,  3.62686041, np.inf])

print(np.arcsinh(y))
# [-inf  -2.  -1.   0.   1.   2.  inf]
```

## 【`arccosh(ndarray)`】
* 逆双曲線余弦

```python
y = np.array([1., 1.54308063, 3.76219569, np.inf])

print(np.arccosh(y))
# [ 0.  1.  2. inf]
```

## 【`arctanh(ndarray)`】
* 逆双曲線正接

```python
y = np.array([-1., -0.96402758, -0.76159416,  0., 0.76159416,  0.96402758, 1.])

print(np.arctanh(y))
# [-inf -2. -1.00000001 0. 1.00000001 2. inf]
```

# R. 乱数生成

Numpyで乱数生成する。

## 【`numpy.random.rand(d0, d1, ..., dn)`】
* 一様分布
* 指定した要素数/次元数の乱数配列を生成する。（乱数の範囲：0以上1未満）

```python
print(np.random.rand())
# 0.5504876218756463

print(np.random.rand(2))
# [0.70029403 0.48969378]

print(np.random.rand(2, 2))
# [[0.98181874 0.47001957]
#  [0.79277853 0.12536121]]
```

## 【`numpy.random.randint(low, high=None, size=None, dtype='l')`】
* 一様分布
* 指定範囲の整数での乱数を生成する。
  * low：最小値（以上。乱数の範囲に含まれる）
  * high：最大値（未満。乱数の範囲に含まれない）
  * size：要素数/次元数
  * dtype：データ型

```python
print(np.random.randint(1,4))
# 2

print(np.random.randint(1,4, 2))
# [2 2]

print(np.random.randint(1,4, (2, 2)))
# [[3 2]
#  [3 1]]
```

## 【`numpy.random.uniform(low=0.0, high=1.0, size=None)`】
* 一様分布
* 指定範囲の乱数を生成する。
  * low：最小値（以上。乱数の範囲に含まれる）
  * high：最大値（未満。乱数の範囲に含まれない）
  * size：要素数/次元数

```python
print(np.random.uniform(1,4))
# 3.5515484791542056

print(np.random.uniform(1,4, 2))
# [1.51270014 3.02435494]

print(np.random.uniform(1,4, (2, 2)))
# [[3.47188029 1.17177563]
#  [3.87198389 3.91458379]]
```

## 【`numpy.random.randn(d0, d1, ..., dn)`】
* 正規分布
* 指定した要素数/次元数の乱数配列を生成する。（平均：0, 標準偏差：1）

```python
print(np.random.randn())
# -0.5775065521096695

print(np.random.randn(2))
# [-1.50501689  1.46743032]

print(np.random.randn(2, 2))
# [[ 1.16357112 -0.24601519]
#  [ 2.07269576 -0.39272309]]
```

## 【`numpy.random.normal(loc=0.0, scale=1.0, size=None)`】
* 正規分布
* 指定の平均・標準偏差の乱数を生成する。
  * loc：平均
  * scale：標準偏差
  * size：要素数/次元数

```python
print(np.random.normal(50, 10))
# 63.47995333571061

print(np.random.normal(50, 10, (2, 2)))
# [[56.02364177 55.25423891]
#  [45.44840171 29.8303964 ]]

print(np.random.normal((50, 0), (10, 1), (5, 2)))
# [[45.48754234 -0.74792452]
#  [60.84696747  1.01209036]
#  [42.38844146 -0.10453915]
#  [39.77544056  1.22264549]
#  [41.60250782  1.64150462]]
```

## 【`numpy.random.binomial(n, p, size=None)`】
* 二項分布
* 指定の試行数・確率の乱数を生成する。
  * n ：試行数
  * p：確率
  * size：要素数/次元数

```python
print(np.random.binomial(100, 0.5))
# 53

print(np.random.binomial(100, 0.5, (2, 2)))
# [[53 53]
#  [48 50]]

print(np.random.binomial((100, 1000), (0.3, 0.7), (5, 2)))
# [[ 33 699]
#  [ 30 660]
#  [ 34 698]
#  [ 26 688]
#  [ 25 683]]
```

## 【`numpy.random.beta(a, b, size=None)`】
* ベータ分布

```python
print(np.random.beta(3, 5))
# 0.09838262724430759
 
print(np.random.beta(8, 2, (2, 2)))
# [[0.92800788 0.86391443]
#  [0.67249524 0.97299346]]
 
print(np.random.beta((3, 8), (5, 2), (5, 2)))
# [[0.11825463 0.74320634]
#  [0.24992266 0.79029969]
#  [0.13345269 0.57807883]
#  [0.32374525 0.92666103]
#  [0.64669681 0.84867388]]
```

## 【`numpy.random.chisquare(df, size=None)`
* カイ二乗分布

```python
print(np.random.chisquare(1))
# 0.05074259859574817
 
print(np.random.chisquare(5, (2, 2)))
# [[ 6.15617206  5.54859677]
#  [ 2.60704305 10.35079434]]
 
print(np.random.chisquare((1, 5), (5, 2)))
# [[2.3942405  6.43803251]
#  [1.97544231 2.73456762]
#  [0.63389405 7.81526263]
#  [0.05035459 7.8224598 ]
#  [1.01597309 1.46098368]]
```

## 【`numpy.random.gamma(shape, scale=1.0, size=None)`】
* ガンマ分布
  * shape：形状パラメータ k
  * scale：尺度パラメータ θ 

```python
print(np.random.gamma(1, 2))
# 0.48471788864900295
 
print(np.random.gamma(9, 1, (2, 2)))
# [[10.71101589 16.68686166]
#  [ 5.22150652  5.87160223]]
 
print(np.random.gamma((1, 9), (2, 1), (5, 2)))
# [[ 3.4102224   6.31938602]
#  [ 0.03882968  7.71108072]
#  [ 2.62781738 10.70853193]
#  [ 5.07929584  5.83489052]
#  [ 1.50577929 11.21572879]]
```

# S. 基本統計

ndarrayの値から基本統計量を算出する。

## 【`max`】
* 最大値

```python
a = np.array([10, 20, 30, 40, 50])
print(np.max(a))
# 50
```

## 【`argmax`】
* 最大値のインデックス

```python
a = np.array([10, 20, 30, 40, 50])
print(np.argmax(a))
# 4
```

## 【`min`】
* 最小値

```python
a = np.array([10, 20, 30, 40, 50])
print(np.min(a))
# 10
```

## 【`argmin`】
* 最小値のインデックス

```python
a = np.array([10, 20, 30, 40, 50])
print(np.argmin(a))
# 0
```

## 【`sum`】
* 合計

```python
a = np.array([10, 20, 30, 40, 50])
print(np.sum(a))
# 150
```

## 【`mean`】
* 平均値

```python
a = np.array([10, 20, 30, 40, 50])
print(np.mean(a))
# 30.0
```

## 【`var`】
* 分散

```python
a = np.array([10, 20, 30, 40, 50])
print(np.var(a))
# 200.0
```

## 【`std`】
* 標準偏差

```python
a = np.array([10, 20, 30, 40, 50])
print(np.std(a))
# 14.142135623730951
```

## 【`cumsum`】
* 累積和

```python
a = np.array([10, 20, 30, 40, 50])
print(np.cumsum(a))
# [ 10  30  60 100 150]
```

## 【`cumsum`】
* 累積積

```python
a = np.array([10, 20, 30, 40, 50])
print(np.cumprod(a))
# [      10      200     6000   240000 12000000]
```

# T. 検証処理

値の検証処理を行う。

## 【`isnan(ndarray)`】
* NaN（Not a number）か否かの判定

```python
y = np.array([np.nan, np.inf, 0, 1])

print(np.isnan(y))
# [ True False False False]
```

## 【`isfinite(ndarray)`】
* 有限（無限でもなくNaNでもない）か否かの判定

```python
y = np.array([np.nan, np.inf, -np.inf, 0, 1])

print(np.isfinite(y))
# [False False False  True  True]
```

## 【`isfin(ndarray)`】
* 無限（有限でもなくNaNでもない）か否かの判定

```python
y = np.array([np.nan, np.inf, -np.inf, 0, 1])

print(np.isinf(y))
# [False  True  True False False]
```

## 【`sign(ndarray)`】
* 符号の判定

```python
y = np.array([-np.inf, -5, 0, 5, np.inf])

print(np.sign(y))
# [-1. -1.  0.  1.  1.]
```

# 備考
本記事はブログ「[雑用エンジニアの技術ノート](https://scrapbox.io/nezuq/)」からの移行記事です。先のブログは削除予定です。