matrix_operation v0.4.4 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.

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.

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.

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.

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.

Linear equations are solved by LU decomposition.

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

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]]
Link to this function

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]]
Link to this function

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]]
Link to this function

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
Link to this function

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]]
Link to this function

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]]
Link to this function

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
Link to this function

diagonalization(a, iter_num \\ 1000)

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. The default value is 1000.

Output

Diagonalized matrix

Example

iex> MatrixOperation.diagonalization([[1, 3], [4, 2]])
[[5.000000000000018, 0], [0, -1.999999999999997]]
iex> MatrixOperation.diagonalization([[2, 1, -1], [1, 1, 5], [-1, 2, 1]])
[[4.101784906061108, 0, 0], [0, -2.6170355220017694, 0], [0, 0, 2.515250615940715]]
iex> MatrixOperation.diagonalization([[2, 1, -1], [1, 1, 0], [-1, 0, 1]])
nil
iex> MatrixOperation.diagonalization([[2, 1, -1], [1, 1, 0], [-1, 0, 1]], 100)
nil
iex> MatrixOperation.diagonalization([[16, -1, 1, 2, 3], [2, 12, 1, 5, 6], [1, 3, -24, 8, 9], [3, 4, 9, 1, 23], [5, 3, 1, 2, 1]], 100)
[
  [-26.608939297937113, 0, 0, 0, 0],
  [0, 20.4243649343814, 0, 0, 0],
  [0, 0, 14.665793374162595, 0, 0],
  [0, 0, 0, -3.547766546408004, 0],
  [0, 0, 0, 0, 1.0665475358009557]
]
Link to this function

eigen(a, iter_num \\ 1000)

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. The default value is 1000.

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]])
{
  [12.17597106504691, -3.6686830979532696, -2.5072879670936357],
  [
    [0.49659978454619125, 0.5773502691896257, 0.6481167492476514],
    [-0.3129856771935595, -0.5773502691896257, 0.7541264035547063],
    [0.8095854617397507, -0.5773502691896256, -0.10600965430705483]
  ]
}
Link to this function

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}
Link to this function

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]]
Link to this function

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]]
Link to this function

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]]
Link to this function

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
Link to this function

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]
Link to this function

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
Link to this function

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]
Link to this function

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]]
Link to this function

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]]
Link to this function

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]]
Link to this function

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]]
Link to this function

jacobi(matrix, iter_num \\ 1000)

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. The default value is 1000.

Output

[Eigenvalues list, Eigenvectors list]: Eigenvalues and eigenvectors

Example

iex> MatrixOperation.jacobi([[10, 3, 2], [3, 5, 1], [2, 1, 0]])
{
  [11.827601656660915, 3.5956497715829547, -0.42325142824210527],
  [
    [0.8892872578006493, -0.42761854121985043, -0.16220529066103917],
    [0.4179466723082575, 0.9038581385546461, -0.09143874712126684],
    [0.1857114757355714, 0.013522151221627882, 0.982511271796136]
  ]
}
Link to this function

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]]
Link to this function

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]]
Link to this function

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]]
}

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

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
Link to this function

power_iteration(matrix, iter_num \\ 1000)

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. The default value is 1000.

Output

Maximum eigenvalue and normalized eigenvector corresponding to the maximum eigenvalue

Example

iex> MatrixOperation.power_iteration([[3, 1], [2, 2]])
{
  4.0,
  [0.7071067811865476, 0.7071067811865476]
}
iex> MatrixOperation.power_iteration([[1, 1, 2], [0, 2, -1], [0, 0, 3]])
{
  3.0,
  [0.3333333333333333, -0.6666666666666666, 0.6666666666666666]
}

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]]
Link to this function

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

Link to this function

rank(matrix, iter_num \\ 1000)

Calculate the rank of a matrix by using QR decomposition

Example

iex> MatrixOperation.rank([[2, 3, 4], [1, 4, 2], [2, 1, 4]])
2
iex> MatrixOperation.rank([[2, 3, 4, 2], [1, 4, 2, 3], [2, 1, 4, 4]])
3
iex> input = [[2, 3, 4, 3], [1, 42, 2, 11], [2, 1, 4, 4], [3, 7, 2, 2], [35, 6, 4, 6], [7, 23, 5, 2]]
iex> MatrixOperation.rank(input)
4
Link to this function

singular_value(a, iter_num \\ 1000)

Calculate singular Value by using QR decomposition.

Argument

  • a: Matrix to calculate singular values.
  • iter_num: iteration number of the QR decomposition. The default value is 1000.

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]])
{14.912172620559879, 4.236463407782015, 1.6369134152873956}

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}
Link to this function

solve_sle(matrix, vertical_vec)

Linear equations are solved by LU decomposition.

Argument

  • matrix: Target matrix to solve simultaneous linear equations.
  • vertical_vec: Vertical vector to solve linear equations.

Output

Solutions of the linear equations

Example

iex> MatrixOperation.solve_sle([[1, 0, 0], [0, 1, 0], [0, 0, 1]], [[1], [0], [0]])
[1.0, 0.0, 0.0]
iex> MatrixOperation.solve_sle([[4, 1, 1], [1, 3, 1], [2, 1, 5]], [[9], [10], [19]])
[1.0, 2.0, 3.0]

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]]
Link to this function

svd(a, iter_num \\ 1000)

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. The default value is 1000.

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]])
{
  [1.0, 1.4142135623730951],
  [
    [1.0, 0.0],
    [0.0, 1.0]
  ],
  [
    [1.0, 0.0, 0.0],
    [0.0, 0.7071067811865475, 0.7071067811865475]
  ]
}
iex> MatrixOperation.svd([[1, 1], [1, -1], [1, 0]])
{
  [1.7320508075688772, 1.4142135623730951],
  [
    [0.5773502691896257, 0.5773502691896257, 0.5773502691896258],
    [0.7071067811865476, -0.7071067811865476, 0.0]
  ],
  [[1.0, 0.0], [0.0, 1.0]]
}
iex> MatrixOperation.svd([[1, 1], [1, 1]])
{
  [1.9999999999999998],
  [
    [0.7071067811865476, 0.7071067811865476]
  ],
  [
    [0.7071067811865476, 0.7071067811865476]
  ]
}
Link to this function

svd_sub(a, a_t, iter_num)

Link to this function

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 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
Link to this function

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

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

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]]
Link to this function

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