# svd_truncated_test

svd_truncated_test, a Python code which calls Python's economy version of the Singular Value Decomposition (SVD) of an M by N rectangular matrix, in cases where M < N or N < M.

The singular value decomposition of an M by N rectangular matrix A has the form

```        A(mxn) = U(mxm) * S(mxn) * V'(nxn)
```
where
• U is an orthogonal matrix, whose columns are the left singular vectors;
• S is a diagonal matrix, whose min(m,n) diagonal entries are the singular values;
• V is an orthogonal matrix, whose columns are the right singular vectors;
Note that the transpose of V is used in the decomposition, and that the diagonal matrix S is typically stored as a vector.

It is often the case that the matrix A has one dimension much bigger than the other. For instance, M = 3 and N = 10,000 might be such a case. For such examples, much of the computation and memory required for the standard SVD may not actually be needed. Instead, a truncated, or reduced version is appropriate. It will be computed faster, and require less memory to store the data.

If M < N, we have the "truncated V" SVD:

```        A(mxn) = U(mxm) * Sm(mxm) * Vm'(nxm)
```
Notice that, for our example, we will have to compute and store a Vm of size 30,000 instead of a V of size 1,000,000 entries.

If N < M, we have the "truncated U" SVD:

```        A(mxn) = Un(mxn) * Sn(nxn) * V'(nxn)
```
Similarly, in this case, the computation and storage of Un can be much reduced from that of U.

The Python function

u, svec, v = np.linalg.svd ( a )
returns the standard SVD. However, a variation of this call returns the truncated SVD:
u, svec, v = svd ( a, full_matrices = False )
This will automatically create the truncated V or truncated U decomposition, depending on whether M < N or N < M.

Note that svec is a vector of singular values, and would have to be promoted to a matrix to represent the usual SVD decomposition. Also, the Python svd() function returns V, not V', unlike many other implementations of the SVD.

### Languages:

svd_truncated_test is available in a C version and a C++ version and a FORTRAN90 version and a MATLAB version and a Python version.

### Related Data and Programs:

fingerprints, a dataset directory which contains a few images of fingerprints.

svd_lls, a Python code which uses the singular value decomposition (SVD) to construct and plot the best affine and linear relationships in the sense of least square, between two vectors of data.

svd_powers, a Python code which applies singular value decomposition (SVD) analysis to powers x(i)^(j-1).

svd_snowfall, a Python code which reads a file containing historical snowfall data and analyzes the data with the singular value decomposition (SVD).

svd_test, a Python code which demonstrates the singular value decomposition (SVD) for a simple example.

### Reference:

1. Edward Anderson, Zhaojun Bai, Christian Bischof, Susan Blackford, James Demmel, Jack Dongarra, Jeremy Du Croz, Anne Greenbaum, Sven Hammarling, Alan McKenney, Danny Sorensen,
LAPACK User's Guide,
Third Edition,
SIAM, 1999,
ISBN: 0898714478,
LC: QA76.73.F25L36
2. Gene Golub, Charles VanLoan,
Matrix Computations, Third Edition,
Johns Hopkins, 1996,
ISBN: 0-8018-4513-X,
LC: QA188.G65.
3. David Kahaner, Cleve Moler, Steven Nash,
Numerical Methods and Software,
Prentice Hall, 1989,
ISBN: 0-13-627258-4,
LC: TA345.K34.
4. Lloyd Trefethen, David Bau,
Numerical Linear Algebra,
SIAM, 1997,
ISBN: 0-89871-361-7,
LC: QA184.T74.

### Source Code:

Last revised on 02 April 2022.