matrix_operation v0.4.1 MatrixOperation
MatrixOperation is a linear algebra library in Elixir language. Matrix indices of a row and column is an integer starting from 1 (not from 0).
Link to this section Summary
Functions
Matrix addition
A matrix is added by a constant.
A matrix is multiplied by a constant.
Cramer's rule
A column of a matrix is deleted.
A row of a matrix is deleted.
A determinant of a n×n square matrix is got.
Matrix diagonalization using the QR decomposition.
Matrix diagonalization using algebra method [R^2×R^2/R^3×R^3 matrix]
Calculate eigenvalues and eigenvectors by using QR decomposition.
Calculate eigenvalue using algebra method [R^2×R^2/R^3×R^3 matrix]
A m×n matrix having even-elements is got.
A column of a matrix is exchanged.
A row of a matrix is exchanged.
Frobenius norm
A column of a matrix is got.
An element of a matrix is got.
A row of a matrix is got.
Hadamard division
Hadamard power
Hadamard product
Inverse Matrix
Calculate eigenvalues and eigenvectors by using Jacobi method
Jordan_normal_form [R^2×R^2/R^3×R^3 matrix]
Leading principal minor is generetaed.
Linear equations are solved by Cramer's rule.
Linear equations are solved by LU decomposition.
LU decomposition
The max norm
The one norm
Power iteration method (maximum eigen value and eigen vector)
Matrix product
A m×n matrix having random elements is got.
Calculate the rank of a matrix by using QR decomposition
Calculate singular Value by using QR decomposition.
Numbers of rows and columns of a matrix are got.
Matrix subtraction
Singular Value Decomposition (SVD) using Jacobi method.
Tensor product
Trace of a matrix
Transpose of a matrix
The two norm
A n-th unit matrix is got.
A variance-covariance matrix is generated.
Link to this section Functions
add(a, b)
Matrix addition
Argument
- a: Left side of the addition of matrices.
- b: Right side of the addition of matrices.
Output
Addition of two matrices
Example
iex> MatrixOperation.add([[3, 2, 3], [2, 1, 2]], [[2, 3, 1], [3, 2, 2]])
[[5, 5, 4], [5, 3, 4]]
const_addition(const, x)
A matrix is added by a constant.
Argument
- const: Constant to add the matrix.
- matrix: Target vector/matrix to be added by a constant.
Output
Vector/Matrix multiplied by the constant.
Example
iex> MatrixOperation.const_addition(1, [1.0, 2.0, 3.0])
[2.0, 3.0, 4.0]
iex> MatrixOperation.const_addition(1, [[1, 2, 3], [2, 2, 2], [3, 8, 9]])
[[2, 3, 4], [3, 3, 3], [4, 9, 10]]
const_multiple(const, x)
A matrix is multiplied by a constant.
Argument
- const: Constant to multiply the matrix.
- matrix: Target vector/matrix to be multiplied by a constant.
Output
Vector/Matrix multiplied by the constant.
Example
iex> MatrixOperation.const_multiple(-1, [1.0, 2.0, 3.0])
[-1.0, -2.0, -3.0]
iex> MatrixOperation.const_multiple(2, [[1, 2, 3], [2, 2, 2], [3, 8, 9]])
[[2, 4, 6], [4, 4, 4], [6, 16, 18]]
cramer(matrix, vertical_vec, select_idx)
Cramer's rule
Argument
- matrix: Target matrix to perform Cramer's rule.
- vertical_vec: Vertical vector to perform Cramer's rule.
- select_idx: Index of the target to perform Cramer's rule.
Output
Solution to the linear equation when Cramer's rule is applied.
Example
iex> MatrixOperation.cramer([[1, 0, 0], [0, 1, 0], [0, 0, 1]], [[1], [0], [0]], 1)
1.0
iex> MatrixOperation.cramer([[0, -2, 1], [-1, 1, -4], [3, 3, 1]], [[3], [-7], [4]], 1)
2.0
delete_one_column(matrix, del_idx)
A column of a matrix is deleted.
Argument
- matrix: Target matrix from which to delete the column.
- del_idx: Index of the column to be deleted.
Output
The matrix from which the specified column was deleted.
Example
iex> MatrixOperation.delete_one_column([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 2)
[[1, 3], [4, 6], [7, 9]]
delete_one_row(matrix, del_idx)
A row of a matrix is deleted.
Argument
- matrix: Target matrix from which to delete the row.
- del_idx: Index of the row to be deleted.
Output
The matrix from which the specified row was deleted.
Example
iex> MatrixOperation.delete_one_row([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3)
[[1, 2, 3], [4, 5, 6]]
determinant(matrix)
A determinant of a n×n square matrix is got.
Argument
- matrix: Target matrix to output determinant.
Output
Determinant of the matrix
Example
iex> MatrixOperation.determinant([[1, 2, 1], [2, 1, 0], [1, 1, 2]])
-5
iex> MatrixOperation.determinant([[1, 2, 1, 1], [2, 1, 0, 1], [1, 1, 2, 1], [1, 2, 3, 4]])
-13
iex> MatrixOperation.determinant([ [3,1,1,2,1], [5,1,3,4,1], [2,0,1,0,1], [1,3,2,1,1], [1,1,1,1,1] ])
-14
diagonalization(a, iter_num)
Matrix diagonalization using the QR decomposition.
Argument
- a: Matrix to be diagonalized by using the QR decomposition.
- iter_num: iteration number of the QR decomposition.
Output
Diagonalized matrix
Example
iex> MatrixOperation.diagonalization([[1, 3], [4, 2]], 100)
[[5.000000000000018, 0], [0, -1.999999999999997]]
iex> MatrixOperation.diagonalization([[2, 1, -1], [1, 1, 5], [-1, 2, 1]], 100)
[[4.101784906061108, 0, 0], [0, -2.407882912725488, 0], [0, 0, 2.3060980066643952]]
iex> MatrixOperation.diagonalization([[2, 1, -1], [1, 1, 0], [-1, 0, 1]], 100)
nil
diagonalization_algebra(matrix)
Matrix diagonalization using algebra method [R^2×R^2/R^3×R^3 matrix]
Argument
- matrix: R^2×R^2/R^3×R^3 matrix. Target matrix to be diagonalized.
Output
Diagonalized matrix
Example
iex> MatrixOperation.diagonalization_algebra([[1, 3], [4, 2]])
[[5.0, 0], [0, -2.0]]
iex> MatrixOperation.diagonalization_algebra([[2, 1, -1], [1, 1, 5], [-1, 2, 1]])
[[-2.6170355131217935, 0, 0], [0, 4.1017849347870765, 0], [0, 0, 2.515250578334717]]
iex> MatrixOperation.diagonalization_algebra([[2, 1, -1], [1, 1, 0], [-1, 0, 1]])
nil
eigen(a, iter_num)
Calculate eigenvalues and eigenvectors by using QR decomposition.
Argument
- a: Matrix to calculate eigenvalues and eigenvectors by using the QR decomposition.
- iter_num: iteration number of the QR decomposition.
Output
[Eigenvalues list, Eigenvectors list]: Eigenvalues and eigenvectors. Eigenvalue is a non-trivial value other than zero.
Example
iex> MatrixOperation.eigen([[1, 4, 5], [4, 2, 6], [5, 6, 3]], 500)
{
[12.17597106504691, -3.6686830979532696, -2.5072879670936357],
[
[0.4965997845719138, 0.577350269219531, 0.6481167492812222],
[0.31298567717874254, 0.5773502691622936, -0.7541264035190053],
[0.8095854617817337, -0.5773502692195656, -0.10600965431255223]
]
}
eigenvalue_algebra(arg1)
Calculate eigenvalue using algebra method [R^2×R^2/R^3×R^3 matrix]
Argument
- [[a11, a12], [a21, a22]] or [[a11, a12, a13], [a21, a22, a23], [a31, a32, a33]]: R^2×R^2/R^3×R^3 matrix
Output
Eigenvalues which is a non-trivial value other than zero.
Example
iex> MatrixOperation.eigenvalue_algebra([[3, 1], [2, 2]])
[4.0, 1.0]
iex> MatrixOperation.eigenvalue_algebra([[6, -3], [4, -1]])
[3.0, 2.0]
iex> MatrixOperation.eigenvalue_algebra([[1, 1, 1], [1, 2, 1], [1, 2, 3]])
[4.561552806429505, 0.43844714673139706, 1.0000000468390973]
iex> MatrixOperation.eigenvalue_algebra([[2, 1, -1], [1, 1, 0], [-1, 0, 1]])
[3.0000000027003626, 0.9999999918989121]
even_matrix(m, n, s)
A m×n matrix having even-elements is got.
Argument
- m: Number of rows in the unit matrix to output.
- n: Number of columns in the unit matrix to output.
- s: Value of the common element of the matrix to output.
Output
A m×n matrix
Example
iex> MatrixOperation.even_matrix(2, 3, 0)
[[0, 0, 0], [0, 0, 0]]
iex> MatrixOperation.even_matrix(3, 2, 1)
[[1, 1], [1, 1], [1, 1]]
exchange_one_column(matrix, exchange_idx, exchange_list)
A column of a matrix is exchanged.
Argument
- matrix: Target matrix from which to exchange the column.
- exchange_idx: Index of the column to be exchanged.
- exchange_list: List of the column to be exchanged.
Output
The matrix from which the specified column was exchanged.
Example
iex> MatrixOperation.exchange_one_column([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 2, [1, 1, 1])
[[1, 1, 3], [4, 1, 6], [7, 1, 9]]
exchange_one_row(matrix, exchange_idx, exchange_list)
A row of a matrix is exchanged.
Argument
- matrix: Target matrix from which to exchange the row.
- exchange_idx: Index of the row to be exchanged.
- exchange_list: List of the row to be exchanged.
Output
The matrix from which the specified row was exchanged.
Example
iex> MatrixOperation.exchange_one_row([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3, [1, 1, 1])
[[1, 2, 3], [4, 5, 6], [1, 1, 1]]
frobenius_norm(a)
Frobenius norm
Argument
- a: Matrix to calculate Frobenius norm.
Output
Frobenius norm
Example
iex> MatrixOperation.frobenius_norm([[2, 3], [1, 4], [2, 1]])
5.916079783099616
iex> MatrixOperation.frobenius_norm([[1, 3, 3], [2, 4, 1], [2, 3, 2]])
7.54983443527075
get_one_column(matrix, col_idx)
A column of a matrix is got.
Argument
- matrix: Target matrix from which to extract the column.
- col_idx: Index of the column to be extracted.
Output
A column of a matrix
Example
iex> MatrixOperation.get_one_column([[1, 2, 3], [4, 5, 6], [7, 8, 9] ], 1)
[1, 4, 7]
get_one_element(matrix, list)
An element of a matrix is got.
Argument
- matrix: Target matrix from which to extract the element.
- [row_idx, col_idx]: Index of row and column of the element to be extracted.
Output
An element of a matrix
Example
iex> MatrixOperation.get_one_element([[1, 2, 3], [4, 5, 6], [7, 8, 9] ], [1, 1])
1
get_one_row(matrix, row_idx)
A row of a matrix is got.
Argument
- matrix: Target matrix from which to extract the row.
- row_idx: Index of the row to be extracted.
Output
A row of a matrix
Example
iex> MatrixOperation.get_one_row([[1, 2, 3], [4, 5, 6], [7, 8, 9] ], 1)
[1, 2, 3]
hadamard_division(a, b)
Hadamard division
Argument
- a: Left side of the Hadamard division of matrices.
- b: Right side of the Hadamard division of matrices.
Output
Hadamard division of two matrices
Example
iex> MatrixOperation.hadamard_division([[3, 2, 3], [2, 1, 2]], [[2, 3, 1], [3, 2, 2]])
[[1.5, 0.6666666666666666, 3.0], [0.6666666666666666, 0.5, 1.0]]
hadamard_power(matrix, n)
Hadamard power
Argument
- matrix: Target matrix that elements are to be n-th powered.
- n: Exponent of a power.
Output
Matrix that elements are to be n-th powered
Example
iex> MatrixOperation.hadamard_power([[3, 2, 3], [2, 1, 2]], 2)
[[9.0, 4.0, 9.0], [4.0, 1.0, 4.0]]
hadamard_product(a, b)
Hadamard product
Argument
- a: Left side of the Hadamard production of matrices.
- b: Right side of the Hadamard production of matrices.
Output
Hadamard production of two matrices
Example
iex> MatrixOperation.hadamard_product([[3, 2, 3], [2, 1, 2]], [[2, 3, 1], [3, 2, 2]])
[[6, 6, 3], [6, 2, 4]]
inverse_matrix(matrix)
Inverse Matrix
Argument
- matrix: Matrix to be inverse Matrix.
Output
Inverse Matrix
Example
iex> MatrixOperation.inverse_matrix([[1, 1, -1], [-2, -1, 1], [-1, -2, 1]])
[[-1.0, -1.0, 0.0], [-1.0, 0.0, -1.0], [-3.0, -1.0, -1.0]]
jacobi(matrix, iter_num)
Calculate eigenvalues and eigenvectors by using Jacobi method
Argument
- matrix: Matrix to adapt the power iteration method.
- iter_num: iteration number of the power iteration method.
Output
[Eigenvalues list, Eigenvectors list]: Eigenvalues and eigenvectors
Example
iex> MatrixOperation.jacobi([[10, 3, 2], [3, 5, 1], [2, 1, 0]], 100)
{
[11.827601656659317, 3.5956497715829547, -0.42325142824210527],
[
[0.8892872578006493, -0.42761854121982545, -0.16220529066103917],
[0.4179466723082325, 0.9038581385545962, -0.09143874712126684],
[0.1857114757355589, 0.013522151221627882, 0.982511271796136]
]
}
jordan_normal_form(arg1)
Jordan_normal_form [R^2×R^2/R^3×R^3 matrix]
Argument
- matrix: R^2×R^2/R^3×R^3 matrix. Target matrix to be Jordan normal form.
Output
Jordan normal form matrix
Example
iex> MatrixOperation.jordan_normal_form([[1, 3], [4, 2]])
[[5.0, 0], [0, -2.0]]
iex> MatrixOperation.jordan_normal_form([[7, 2], [-2, 3]])
[[5.0, 1], [0, 5.0]]
iex> MatrixOperation.jordan_normal_form([[2, 1, -1], [1, 1, 0], [-1, 0, 1]])
nil
iex> MatrixOperation.jordan_normal_form([[1, -1, 1], [0, 2, -2], [1, 1, 3]])
[[2.0, 1, 0], [0, 2.0, 1], [0, 0, 2.0]]
iex> MatrixOperation.jordan_normal_form([[3, 0, 1], [-1, 2, -1], [-1, 0, 1]])
[[2.0, 1, 0], [0, 2.0, 0], [0, 0, 2.0]]
iex> MatrixOperation.jordan_normal_form([[1, 0, -1], [0, 2, 0], [0, 1, 1]])
[[2.0, 0, 0], [0, 0.9999999999999999, 1], [0, 0, 0.9999999999999999]]
iex> MatrixOperation.jordan_normal_form([[6, 2, 3], [-3, 0, -2], [-4, -2, -1]])
[[1.0, 0, 0], [0, 2.0, 1], [0, 0, 2.0]]
leading_principal_minor(matrix, idx)
Leading principal minor is generetaed.
Argument
- matrix: Target matrix to find leading principal minor.
- idx: Index of a row and column to find leading principal minor.
Output
Leading principal minor
Example
iex> MatrixOperation.leading_principal_minor([[1, 3, 2], [2, 5, 1], [3, 4, 5]], 2)
[[1, 3], [2, 5]]
linear_equations_cramer(matrix, vertical_vec)
Linear equations are solved by Cramer's rule.
Argument
- matrix: Target matrix to solve linear equations.
- vertical_vec: Vertical vector to solve linear equations.
Output
Solutions of the linear equations
Example
iex> MatrixOperation.linear_equations_cramer([[1, 0, 0], [0, 1, 0], [0, 0, 1]], [[1], [0], [0]])
[1.0, 0.0, 0.0]
iex> MatrixOperation.linear_equations_cramer([[1, 0, 0], [0, 1, 0], [0, 0, 1]], [[1], [0], [0]])
[1.0, 0.0, 0.0]
linear_equations_direct(matrix, vertical_vec)
Linear equations are solved by LU decomposition.
Argument
- matrix: Target matrix to solve linear equations.
- vertical_vec: Vertical vector to solve linear equations.
Output
Solutions of the linear equations
Example
iex> MatrixOperation.linear_equations_direct([[1, 0, 0], [0, 1, 0], [0, 0, 1]], [[1], [0], [0]])
[1.0, 0.0, 0.0]
iex> MatrixOperation.linear_equations_direct([[4, 1, 1], [1, 3, 1], [2, 1, 5]], [[9], [10], [19]])
[1.0, 2.0, 3.0]
lu_decomposition(matrix)
LU decomposition
Argument
- matrix: Target matrix to solve LU decomposition.
Output
[L, U]: L(U) is L(U)-matrix of LU decomposition.
Example
iex> MatrixOperation.lu_decomposition([[1, 1, 0, 3], [2, 1, -1, 1], [3, -1, -1, 2], [-1, 2, 3, -1]])
[
[[1, 0, 0, 0], [2.0, 1, 0, 0], [3.0, 4.0, 1, 0], [-1.0, -3.0, 0.0, 1]],
[[1, 1, 0, 3], [0, -1.0, -1.0, -5.0], [0, 0, 3.0, 13.0], [0, 0, 0, -13.0]]
]
max_norm(a)
The max norm
Argument
- a: Matrix to calculate the max norm.
Output
The max norm
Example
iex> MatrixOperation.max_norm([[2, 3], [1, 4], [2, 1]])
8
iex> MatrixOperation.max_norm([[1, 3, 3], [2, 4, 1], [2, 3, 2]])
10
one_norm(a)
The one norm
Argument
- a: Matrix to calculate the one norm.
Output
one norm
Example
iex> MatrixOperation.one_norm([[2, 3], [1, 4], [2, 1]])
5
iex> MatrixOperation.one_norm([[1, 3, 3], [2, 4, 1], [2, 3, 2]])
7
power_iteration(matrix, iter_num)
Power iteration method (maximum eigen value and eigen vector)
Argument
- matrix: Matrix to adapt the power iteration method.
- iter_num: iteration number of the power iteration method.
Output
Maximum eigen value and eigen vector
Example
iex> MatrixOperation.power_iteration([[3, 1], [2, 2]], 100)
[
4.0,
[2.8284271247461903, 2.8284271247461903]
]
iex> MatrixOperation.power_iteration([[1, 1, 2], [0, 2, -1], [0, 0, 3]], 100)
[
3.0,
[1.0, -2.0, 2.0]
]
product(a, b)
Matrix product
Argument
- a: Left side of the product of matrices.
- b: Right side of the product of matrices.
Output
Product of two matrices
Example
iex> MatrixOperation.product([[3, 2, 3], [2, 1, 2]], [[2, 3], [2, 1], [3, 5]])
[[19, 26], [12, 17]]
random_matrix(m, n, min_val, max_val, type)
A m×n matrix having random elements is got.
Argument
- m: Number of rows in the unit matrix to output.
- n: Number of columns in the unit matrix to output.
- min_val: Minimum value of random number.
- max_val: Maximum value of random number.
- type: Data type of elements. "int" or "real".
Output
A m×n matrix
rank(matrix, iter_num)
Calculate the rank of a matrix by using QR decomposition
Example
iex> MatrixOperation.rank([[2, 3, 4], [1, 4, 2], [2, 1, 4]], 100)
2
iex> MatrixOperation.rank([[2, 3, 4, 2], [1, 4, 2, 3], [2, 1, 4, 4]], 100)
3
singular_value(a, iter_num)
Calculate singular Value by using QR decomposition.
Argument
- a: Matrix to calculate singular values.
- iter_num: iteration number of the QR decomposition.
Output
Singular values list. Singular value is a non-trivial value other than zero.
Example
iex> MatrixOperation.singular_value([[1, 2, 3, 1], [2, 4, 1, 5], [3, 3, 10, 8]], 100)
[14.912172620559879, 4.236463407782015, 1.6369134152873956]
size(matrix)
Numbers of rows and columns of a matrix are got.
Argument
- matrix: Target matrix for finding the numbers of rows and columns.
Output
{num_rows, num_cols}: Numbers of rows and columns of a matrix
Example
iex> MatrixOperation.size([[3, 2, 3], [2, 1, 2]])
{2, 3}
subtract(a, b)
Matrix subtraction
Argument
- a: Left side of the subtraction of matrices.
- b: Right side of the subtraction of matrices.
Output
Subtraction of two matrices
Example
iex> MatrixOperation.subtract([[3, 2, 3], [2, 1, 2]], [[2, 3, 1], [3, 2, 2]])
[[1, -1, 2], [-1, -1, 0]]
svd(a, iter_num)
Singular Value Decomposition (SVD) using Jacobi method.
Argument
- matrix: Matrix to adapt the SVD by using the QR decomposition method.
- iter_num: iteration number of the QR decomposition method
Output
[Singular values, U-matrix, V-matrix]:
Singular values, U-matrix and V-matrix.
Singular value is a non-trivial value other than zero.
Example
iex> MatrixOperation.svd([[1, 0, 0], [0, 1, 1]], 100)
{
[1.0, 1.4142135623730951],
[
[1.0000000000001104, 0.0],
[0.0, 1.0000000000001101]
],
[
[1.0000000000001104, 0.0, 0.0],
[0.0, 0.7071067811836627, 0.7071067811836627]
]
}
iex> MatrixOperation.svd([[1, 1], [1, -1], [1, 0]], 100)
{
[1.7320508075688772, 1.4142135623730951],
[
[0.5773502691779367, 0.5773502691779367, 0.5773502691779369],
[0.7071067811583637, -0.7071067811583637, 0.0]
],
[
[0.9999999999978897, 0.0],
[0.0, 1.0000000000001104]
]
}
iex> MatrixOperation.svd([[1, 1], [1, 1]], 100)
{
[1.9999999999999998],
[[0.7071067811786672, 0.7071067811786672]],
[[0.7071067811786672, 0.7071067811786672]]
}
svd_sub(a, a_t, iter_num)
tensor_product(a, b)
Tensor product
Argument
- a: Left side of the tensor production of matrices.
- b: Right side of the tensor production of matrices.
Output
Tensor production of two matrices
Example
iex> MatrixOperation.tensor_product([[3, 2, 3], [2, 1, 2]], [[2, 3, 1], [2, 1, 2], [3, 5, 3]])
[
[
[[6, 9, 3], [6, 3, 6], [9, 15, 9]],
[[4, 6, 2], [4, 2, 4], [6, 10, 6]],
[[6, 9, 3], [6, 3, 6], [9, 15, 9]]
],
[
[[4, 6, 2], [4, 2, 4], [6, 10, 6]],
[[2, 3, 1], [2, 1, 2], [3, 5, 3]],
[[4, 6, 2], [4, 2, 4], [6, 10, 6]]
]
]
trace(matrix)
Trace of a matrix
Argument
- matrix: Target matrix to output trace.
Output
Trance of the matrix
Example
iex> MatrixOperation.trace([[1.0, 2.0], [3.0, 4.0]])
5.0
transpose(matrix)
Transpose of a matrix
Argument
- matrix: Target matrix to transpose.
Output
Transposed matrix
Example
iex> MatrixOperation.transpose([[1.0, 2.0], [3.0, 4.0]])
[[1.0, 3.0], [2.0, 4.0]]
two_norm(a)
The two norm
Argument
- a: Matrix to calculate the two norm.
Output
The two norm
Example
iex> MatrixOperation.two_norm([[2, 3], [1, 4], [2, 1]])
5.674983803488139
iex> MatrixOperation.two_norm([[1, 3, 3], [2, 4, 1], [2, 3, 2]])
7.329546646114924
unit_matrix(n)
A n-th unit matrix is got.
Argument
- n: Number of rows / columns in the unit matrix to output.
Output
A n-th unit matrix
Example
iex> MatrixOperation.unit_matrix(3)
[[1, 0, 0], [0, 1, 0], [0, 0, 1]]
variance_covariance_matrix(data)
A variance-covariance matrix is generated.
Argument
- data: x and y coordinate lists ([[x_1, y_1], [x_2, y_2], ...]) to calculate variance-covariance matrix.
Output
Variance-covariance matrix
Example
iex> MatrixOperation.variance_covariance_matrix([[40, 80], [80, 90], [90, 100]])
[
[466.66666666666663, 166.66666666666666],
[166.66666666666666, 66.66666666666666]
]