Computation of SVD by Using C (Linear Algebra: Matrix Decomposition)

Linear Algebra

PROGRAMMES IN PYTHON AND C LANGUAGES

UNIT − IV: MATRIX DECOMPOSITION

COMPUTATION OF SVD BY USING C

Computing the Singular Value Decomposition (SVD) of a matrix in C typically involves using external libraries that provide optimized numerical routines. There are no "built−in" SVD functions in standard C, as it is a low−level language without inherent support for advanced mathematical operations like matrix decomposition.

The most common and recommended approach is to link against a high−performance linear algebra library. The LAPACK (Linear Algebra Package) library, or its C−interface counterpart CLAPACK, is the standard for such computations.

Here's how we can use LAPACK/CLAPACK for SVD in C:

• Obtain LAPACK/CLAPACK: We need to install or link against a LAPACK or CLAPACK implementation. This often involves compiling the library or using a pre−compiled version provided by our system's package manager. For example, on Linux, you might install liblapack−dev and libblas−dev.

• Include necessary headers: When using CLAPACK, we would include its specific header files. For example, we might include <clapack.h>.

• Use the dgesvd_function: The core function for computing SVD in LAPACK/CLAPACK is dgevd_(for double−precision general matrices). This function takes the input matrix, dimensions, and pointers to arrays re the U, S and V matrices (or their transposes) will be stored.

Example (Conceptual, as full CLAPACK setup is extensive):

C

#include <stdio.h>

#include <stdlib.h>

// Assuming you have clapack.h or similar for LAPACK interface

// #include <clapack.h>

// Function signature for dgesvd (from LAPACK documentation)

//extern void dgesvd_(char *jobu, char *jobvt, int *m, int *n, double *a,

// int *Lda, double *s, double *u, int *1du,  double *vt,

//int *Lvdt, double *work, int *Lwork, int *info);

int  main()

{

// Example matrix A (m x n)

int m = 3;

int n =  2;

double A[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0};

// Stored in column−major order

// Output matrices

double S[2]; // Singular values (min (m, n))

double * U[3 * 3]; / Left Singular vectors (m x m)

double VT [2 * 2]; // Tranpose of right singular vectors (n ×_n)

// Workspace and info variables for dgesvd_double work [1];

// placeholder for optimal workspace size

int lwork = −1; // Query for optimal workspace size int info;

// Query for optimal workspace size

char jobu = 'A'; // Compute all m columns of U

char sobrt = 'A'; // compute all n rows of V^T

int 1da = m; // Leading dimension of A

int 1du = m; // Leading dimension of U

1dvt = n; // Leading dimension of VT

// dgesvd_(&jobu, &jovt, &m, &n, A, &Lda, S, U, & Ldu, VT, &Ldvt, &jobvt, work, &Lwork,

// Lwork = (int) work [0]; // Get optimal workspace size

// double* actual_work = (double*) maLLoc (Lwork*sizeof (double));

// Perform SVD (assuming actual_work is aLLocated)

// dgesvd_ (&jobu, &jobvt, &m, &n, A, &Lda, S, U, &Ldu, VT, &Lvdt, actual_work,

// After calling dgesvd, S, U and VT will contain the results.

// Error handling for info variable should implemented.

// Free allocated momory

// free (actual work);

printf("SVD computation would be performed using dgesvd_from LAPACK/CLAPACK.\n");

printf("The matrices U, S and V^T would be populated with the results.\n");

return 0;

}