# 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

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.

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.

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

Link to this function

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

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.

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.

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

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

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

#### 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.

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 is generetaed.

#### Argument

• matrix: Target matrix to find leading principal minor.
• idx: Index of a row and column to find 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]]
}``````
Link to this function

# max_norm(a)

The max norm

#### Argument

• a: Matrix to calculate the max norm.

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

# one_norm(a)

The one norm

#### Argument

• a: Matrix to calculate the one norm.

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

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

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

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

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

# two_norm(a)

The two norm

#### Argument

• a: Matrix to calculate the two norm.

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

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