/* cs_qr: sparse QR factorization */
void mexFunction
(
int nargout,
mxArray *pargout [ ],
int nargin,
const mxArray *pargin [ ]
)
{
css *S ;
csn *N ;
cs Amatrix, *A, *D ;
csi m, n, order, *p ;
if (nargout > 5 || nargin != 1)
{
mexErrMsgTxt ("Usage: [V,beta,p,R,q] = cs_qr(A)") ;
}
A = cs_mex_get_sparse (&Amatrix, 0, 1, pargin [0]) ; /* get A */
m = A->m ;
n = A->n ;
if (m < n) mexErrMsgTxt ("A must have # rows >= # columns") ;
order = (nargout == 5) ? 3 : 0 ; /* determine ordering */
S = cs_sqr (order, A, 1) ; /* symbolic QR ordering & analysis*/
N = cs_qr (A, S) ; /* numeric QR factorization */
if (!N) mexErrMsgTxt ("qr failed") ;
cs_dropzeros (N->L) ; /* drop zeros from V and sort */
D = cs_transpose (N->L, 1) ;
cs_spfree (N->L) ;
N->L = cs_transpose (D, 1) ;
cs_spfree (D) ;
cs_dropzeros (N->U) ; /* drop zeros from R and sort */
D = cs_transpose (N->U, 1) ;
cs_spfree (N->U) ;
N->U = cs_transpose (D, 1) ;
cs_spfree (D) ;
m = N->L->m ; /* m may be larger now */
p = cs_pinv (S->pinv, m) ; /* p = pinv' */
pargout [0] = cs_mex_put_sparse (&(N->L)) ; /* return V */
cs_mex_put_double (n, N->B, &(pargout [1])) ; /* return beta */
pargout [2] = cs_mex_put_int (p, m, 1, 1) ; /* return p */
pargout [3] = cs_mex_put_sparse (&(N->U)) ; /* return R */
pargout [4] = cs_mex_put_int (S->q, n, 1, 0) ; /* return q */
cs_nfree (N) ;
cs_sfree (S) ;
}
/* cs_ltsolve: solve an upper triangular system L'*x=b */
void mexFunction
(
int nargout,
mxArray *pargout [ ],
int nargin,
const mxArray *pargin [ ]
)
{
cs Lmatrix, *L ;
double *x, *b ;
if (nargout > 1 || nargin != 2)
{
mexErrMsgTxt ("Usage: x = cs_ltsolve(L,b)") ;
}
L = cs_mex_get_sparse (&Lmatrix, 1, 1, pargin [0]) ; /* get L */
b = cs_mex_get_double (L->n, pargin [1]) ; /* get b */
x = cs_mex_put_double (L->n, b, &(pargout [0])) ; /* x = b */
cs_ltsolve (L, x) ; /* x = L'\x */
}
void mexFunction
(
int nargout,
mxArray *pargout [ ],
int nargin,
const mxArray *pargin [ ]
)
{
cs Umatrix, Bmatrix, *U, *B, *X ;
double *x, *b ;
int top, nz, p, *xi ;
if (nargout > 1 || nargin != 2)
{
mexErrMsgTxt ("Usage: x = cs_usolve(U,b)") ;
}
U = cs_mex_get_sparse (&Umatrix, 1, 1, pargin [0]) ; /* get U */
if (mxIsSparse (pargin [1]))
{
B = cs_mex_get_sparse (&Bmatrix, 0, 1, pargin [1]) ;/* get sparse b */
cs_mex_check (0, U->n, 1, 0, 1, 1, pargin [1]) ;
xi = cs_malloc (2*U->n, sizeof (int)) ; /* get workspace */
x = cs_malloc (U->n, sizeof (double)) ;
top = cs_spsolve (U, B, 0, xi, x, NULL, 0) ; /* x = U\b */
X = cs_spalloc (U->n, 1, U->n-top, 1, 0) ; /* create sparse x*/
X->p [0] = 0 ;
nz = 0 ;
for (p = top ; p < U->n ; p++)
{
X->i [nz] = xi [p] ;
X->x [nz++] = x [xi [p]] ;
}
X->p [1] = nz ;
pargout [0] = cs_mex_put_sparse (&X) ;
cs_free (x) ;
cs_free (xi) ;
}
else
{
b = cs_mex_get_double (U->n, pargin [1]) ; /* get full b */
x = cs_mex_put_double (U->n, b, &(pargout [0])) ; /* x = b */
cs_usolve (U, x) ; /* x = U\x */
}
}
/* z = cs_gaxpy (A,x,y) computes z = A*x+y */
void mexFunction
(
int nargout,
mxArray *pargout [ ],
int nargin,
const mxArray *pargin [ ]
)
{
cs Amatrix, *A ;
double *x, *y, *z ;
if (nargout > 1 || nargin != 3)
{
mexErrMsgTxt ("Usage: z = cs_gaxpy(A,x,y)") ;
}
A = cs_mex_get_sparse (&Amatrix, 0, 1, pargin [0]) ; /* get A */
x = cs_mex_get_double (A->n, pargin [1]) ; /* get x */
y = cs_mex_get_double (A->m, pargin [2]) ; /* get y */
z = cs_mex_put_double (A->m, y, &(pargout [0])) ; /* z = y */
cs_gaxpy (A, x, z) ; /* z = z + A*x */
}
/* cs_lusol: solve A*x=b using a sparse LU factorization */
void mexFunction
(
int nargout,
mxArray *pargout [ ],
int nargin,
const mxArray *pargin [ ]
)
{
cs *A, Amatrix ;
csi order ;
double *x, *b, tol ;
if (nargout > 1 || nargin < 2 || nargin > 4)
{
mexErrMsgTxt ("Usage: x = cs_lusol(A,b,order,tol)") ;
}
A = cs_mex_get_sparse (&Amatrix, 1, 1, pargin [0]) ; /* get A */
b = cs_mex_get_double (A->n, pargin [1]) ; /* get b */
x = cs_mex_put_double (A->n, b, &(pargout [0])) ; /* x = b */
order = (nargin < 3) ? 2 : mxGetScalar (pargin [2]) ;
order = CS_MAX (order, 0) ;
order = CS_MIN (order, 3) ;
if (nargin == 2)
{
tol = 1 ; /* normal partial pivoting */
}
else if (nargin == 3)
{
tol = (order == 1) ? 0.001 : 1 ; /* tol = 0.001 for amd(A+A') */
}
else
{
tol = mxGetScalar (pargin [3]) ;
}
if (!cs_lusol (order, A, x, tol)) /* x = A\x */
{
mexErrMsgTxt ("LU factorization failed (singular or out of memory)") ;
}
}