Repository: systemml Updated Branches: refs/heads/master 3ca91e68c -> 22905278c
[MINOR] Doc svd builtin function in dml ref Closes #704. Project: http://git-wip-us.apache.org/repos/asf/systemml/repo Commit: http://git-wip-us.apache.org/repos/asf/systemml/commit/22905278 Tree: http://git-wip-us.apache.org/repos/asf/systemml/tree/22905278 Diff: http://git-wip-us.apache.org/repos/asf/systemml/diff/22905278 Branch: refs/heads/master Commit: 22905278cc98ddadd69720a1b695c4d724093fa7 Parents: 3ca91e6 Author: j143 <[email protected]> Authored: Mon Dec 4 11:58:24 2017 -0800 Committer: Matthias Boehm <[email protected]> Committed: Mon Dec 4 11:58:24 2017 -0800 ---------------------------------------------------------------------- docs/dml-language-reference.md | 1 + 1 file changed, 1 insertion(+) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/systemml/blob/22905278/docs/dml-language-reference.md ---------------------------------------------------------------------- diff --git a/docs/dml-language-reference.md b/docs/dml-language-reference.md index e377596..a0cc0f7 100644 --- a/docs/dml-language-reference.md +++ b/docs/dml-language-reference.md @@ -838,6 +838,7 @@ eigen() | Computes Eigen decomposition of input matrix A. The Eigen decompositio lu() | Computes Pivoted LU decomposition of input matrix A. The LU decomposition consists of three matrices P, L, and U such that P %\*% A = L %\*% U, where P is a permutation matrix that is used to rearrange the rows in A before the decomposition can be computed. L is a lower-triangular matrix whereas U is an upper-triangular matrix. <br/> It is important to note that this function can operate only on small-to-medium sized input matrix that can fit in the main memory. For larger matrices, an out-of-memory exception is raised. | Input : (A <matrix>) <br/> Output : [<matrix>, <matrix>, <matrix>] <br/> A is a square matrix with dimensions m x m. This function returns three matrices P, L, and U, all of which are of size m x m. | [P, L, U] = lu(A) qr() | Computes QR decomposition of input matrix A using Householder reflectors. The QR decomposition of A consists of two matrices Q and R such that A = Q%\*%R where Q is an orthogonal matrix (i.e., Q%\*%t(Q) = t(Q)%\*%Q = I, identity matrix) and R is an upper triangular matrix. For efficiency purposes, this function returns the matrix of Householder reflector vectors H instead of Q (which is a large m x m potentially dense matrix). The Q matrix can be explicitly computed from H, if needed. In most applications of QR, one is interested in calculating Q %\*% B or t(Q) %\*% B â and, both can be computed directly using H instead of explicitly constructing the large Q matrix. <br/> It is important to note that this function can operate only on small-to-medium sized input matrix that can fit in the main memory. For larger matrices, an out-of-memory exception is raised. | Input : (A <matrix>) <br/> Output : [<matrix>, <matrix>] <br/> A is a (m x n) matrix, which can e ither be a square matrix (m=n) or a rectangular matrix (m != n). This function returns two matrices H and R of size (m x n) i.e., same size as of the input matrix A. | [H, R] = qr(A) solve() | Computes the least squares solution for system of linear equations A %\*% x = b i.e., it finds x such that \|\|A%*%x â b\|\| is minimized. The solution vector x is computed using a QR decomposition of A. <br/> It is important to note that this function can operate only on small-to-medium sized input matrix that can fit in the main memory. For larger matrices, an out-of-memory exception is raised. | Input : (A <(m x n) matrix>, b <(m x 1) matrix>) <br/> Output : <matrix> <br/> A is a matrix of size (m x n) and b is a 1D matrix of size m x 1. This function returns a 1D matrix x of size n x 1. | x = solve(A,b) +svd() | Singular Value Decomposition of a matrix A (of size m x m), which decomposes into three matrices U, V, and S as A = U %*% S %*% t(V), where U is an m x m unitary matrix (i.e., orthogonal), V is an n x n unitary matrix (also orthogonal), and S is an m x n matrix with non-negative real numbers on the diagonal. | Input: matrix A <(m x n)> <br/> Output: matrices U <(m x m)>, S <(m x n)>, and V <(n x n)> | [U, S, V] = svd(A) t() | Transpose matrix | Input: matrix <br/> Output: matrix | t(X) trace() | Return the sum of the cells of the main diagonal square matrix | Input: matrix <br/> Output: scalar | trace(X)
