SEXP dsCMatrix_chol(SEXP x, SEXP pivot) { int pivP = asLogical(pivot); CHM_FR L = internal_chm_factor(x, pivP, 0, 0, 0.); CHM_SP R, Rt; SEXP ans; Rt = cholmod_l_factor_to_sparse(L, &c); R = cholmod_l_transpose(Rt, /*values*/ 1, &c); cholmod_l_free_sparse(&Rt, &c); ans = PROTECT(chm_sparse_to_SEXP(R, 1/*do_free*/, 1/*uploT*/, 0/*Rkind*/, "N"/*diag*/, GET_SLOT(x, Matrix_DimNamesSym))); if (pivP) { SEXP piv = PROTECT(allocVector(INTSXP, L->n)); int *dest = INTEGER(piv), *src = (int*)L->Perm; for (int i = 0; i < L->n; i++) dest[i] = src[i] + 1; setAttrib(ans, install("pivot"), piv); setAttrib(ans, install("rank"), ScalarInteger((size_t) L->minor)); UNPROTECT(1); } cholmod_l_free_factor(&L, &c); UNPROTECT(1); return ans; }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { double dummy = 0, *px ; cholmod_sparse Amatrix, *A, *Lsparse, *R ; cholmod_factor *L ; cholmod_common Common, *cm ; Long n, minor ; /* ---------------------------------------------------------------------- */ /* start CHOLMOD and set parameters */ /* ---------------------------------------------------------------------- */ cm = &Common ; cholmod_l_start (cm) ; sputil_config (SPUMONI, cm) ; /* convert to packed LL' when done */ cm->final_asis = FALSE ; cm->final_super = FALSE ; cm->final_ll = TRUE ; cm->final_pack = TRUE ; cm->final_monotonic = TRUE ; /* no need to prune entries due to relaxed supernodal amalgamation, since * zeros are dropped with sputil_drop_zeros instead */ cm->final_resymbol = FALSE ; cm->quick_return_if_not_posdef = (nargout < 2) ; /* ---------------------------------------------------------------------- */ /* get inputs */ /* ---------------------------------------------------------------------- */ if (nargin != 1 || nargout > 3) { mexErrMsgTxt ("usage: [R,p,q] = chol2 (A)") ; } n = mxGetN (pargin [0]) ; if (!mxIsSparse (pargin [0]) || n != mxGetM (pargin [0])) { mexErrMsgTxt ("A must be square and sparse") ; } /* get input sparse matrix A. Use triu(A) only */ A = sputil_get_sparse (pargin [0], &Amatrix, &dummy, 1) ; /* use natural ordering if no q output parameter */ if (nargout < 3) { cm->nmethods = 1 ; cm->method [0].ordering = CHOLMOD_NATURAL ; cm->postorder = FALSE ; } /* ---------------------------------------------------------------------- */ /* analyze and factorize */ /* ---------------------------------------------------------------------- */ L = cholmod_l_analyze (A, cm) ; cholmod_l_factorize (A, L, cm) ; if (nargout < 2 && cm->status != CHOLMOD_OK) { mexErrMsgTxt ("matrix is not positive definite") ; } /* ---------------------------------------------------------------------- */ /* convert L to a sparse matrix */ /* ---------------------------------------------------------------------- */ /* the conversion sets L->minor back to n, so get a copy of it first */ minor = L->minor ; Lsparse = cholmod_l_factor_to_sparse (L, cm) ; if (Lsparse->xtype == CHOLMOD_COMPLEX) { /* convert Lsparse from complex to zomplex */ cholmod_l_sparse_xtype (CHOLMOD_ZOMPLEX, Lsparse, cm) ; } if (minor < n) { /* remove columns minor to n-1 from Lsparse */ sputil_trim (Lsparse, minor, cm) ; } /* drop zeros from Lsparse */ sputil_drop_zeros (Lsparse) ; /* Lsparse is lower triangular; conjugate transpose to get R */ R = cholmod_l_transpose (Lsparse, 2, cm) ; cholmod_l_free_sparse (&Lsparse, cm) ; /* ---------------------------------------------------------------------- */ /* return results to MATLAB */ /* ---------------------------------------------------------------------- */ /* return R */ pargout [0] = sputil_put_sparse (&R, cm) ; /* return minor (translate to MATLAB convention) */ if (nargout > 1) { pargout [1] = mxCreateDoubleMatrix (1, 1, mxREAL) ; px = mxGetPr (pargout [1]) ; px [0] = ((minor == n) ? 0 : (minor+1)) ; } /* return permutation */ if (nargout > 2) { pargout [2] = sputil_put_int (L->Perm, n, 1) ; } /* ---------------------------------------------------------------------- */ /* free workspace and the CHOLMOD L, except for what is copied to MATLAB */ /* ---------------------------------------------------------------------- */ cholmod_l_free_factor (&L, cm) ; cholmod_l_finish (cm) ; cholmod_l_print_common (" ", cm) ; /* if (cm->malloc_count != (3 + mxIsComplex (pargout[0]))) mexErrMsgTxt ("!") ; */ }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { double dummy = 0, beta [2], *px ; cholmod_sparse Amatrix, *A, *Lsparse ; cholmod_factor *L ; cholmod_common Common, *cm ; Long n, minor ; /* ---------------------------------------------------------------------- */ /* start CHOLMOD and set parameters */ /* ---------------------------------------------------------------------- */ cm = &Common ; cholmod_l_start (cm) ; sputil_config (SPUMONI, cm) ; /* convert to packed LDL' when done */ cm->final_asis = FALSE ; cm->final_super = FALSE ; cm->final_ll = FALSE ; cm->final_pack = TRUE ; cm->final_monotonic = TRUE ; /* since numerically zero entries are NOT dropped from the symbolic * pattern, we DO need to drop entries that result from supernodal * amalgamation. */ cm->final_resymbol = TRUE ; cm->quick_return_if_not_posdef = (nargout < 2) ; /* This will disable the supernodal LL', which will be slow. */ /* cm->supernodal = CHOLMOD_SIMPLICIAL ; */ /* ---------------------------------------------------------------------- */ /* get inputs */ /* ---------------------------------------------------------------------- */ if (nargin < 1 || nargin > 2 || nargout > 3) { mexErrMsgTxt ("usage: [L,p,q] = ldlchol (A,beta)") ; } n = mxGetM (pargin [0]) ; if (!mxIsSparse (pargin [0])) { mexErrMsgTxt ("A must be sparse") ; } if (nargin == 1 && n != mxGetN (pargin [0])) { mexErrMsgTxt ("A must be square") ; } /* get sparse matrix A, use tril(A) */ A = sputil_get_sparse (pargin [0], &Amatrix, &dummy, -1) ; if (nargin == 1) { A->stype = -1 ; /* use lower part of A */ beta [0] = 0 ; beta [1] = 0 ; } else { A->stype = 0 ; /* use all of A, factorizing A*A' */ beta [0] = mxGetScalar (pargin [1]) ; beta [1] = 0 ; } /* use natural ordering if no q output parameter */ if (nargout < 3) { cm->nmethods = 1 ; cm->method [0].ordering = CHOLMOD_NATURAL ; cm->postorder = FALSE ; } /* ---------------------------------------------------------------------- */ /* analyze and factorize */ /* ---------------------------------------------------------------------- */ L = cholmod_l_analyze (A, cm) ; cholmod_l_factorize_p (A, beta, NULL, 0, L, cm) ; if (nargout < 2 && cm->status != CHOLMOD_OK) { mexErrMsgTxt ("matrix is not positive definite") ; } /* ---------------------------------------------------------------------- */ /* convert L to a sparse matrix */ /* ---------------------------------------------------------------------- */ /* the conversion sets L->minor back to n, so get a copy of it first */ minor = L->minor ; Lsparse = cholmod_l_factor_to_sparse (L, cm) ; if (Lsparse->xtype == CHOLMOD_COMPLEX) { /* convert Lsparse from complex to zomplex */ cholmod_l_sparse_xtype (CHOLMOD_ZOMPLEX, Lsparse, cm) ; } /* ---------------------------------------------------------------------- */ /* return results to MATLAB */ /* ---------------------------------------------------------------------- */ /* return L as a sparse matrix (it may contain numerically zero entries) */ pargout [0] = sputil_put_sparse (&Lsparse, cm) ; /* return minor (translate to MATLAB convention) */ if (nargout > 1) { pargout [1] = mxCreateDoubleMatrix (1, 1, mxREAL) ; px = mxGetPr (pargout [1]) ; px [0] = ((minor == n) ? 0 : (minor+1)) ; } /* return permutation */ if (nargout > 2) { pargout [2] = sputil_put_int (L->Perm, n, 1) ; } /* ---------------------------------------------------------------------- */ /* free workspace and the CHOLMOD L, except for what is copied to MATLAB */ /* ---------------------------------------------------------------------- */ cholmod_l_free_factor (&L, cm) ; cholmod_l_finish (cm) ; cholmod_l_print_common (" ", cm) ; /* if (cm->malloc_count != 3 + mxIsComplex (pargout[0])) mexErrMsgTxt ("!") ; */ }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { int ki; double dummy = 0 ; double *Lx, *Lx2 ; Int *Li, *Lp, *Li2, *Lp2, *Lnz2, *ColCount ; cholmod_sparse Cmatrix, *R, *Lsparse ; cholmod_factor *L ; cholmod_common Common, *cm ; Int j, k, s, update, n, lnz ; char buf [LEN] ; /* ---------------------------------------------------------------------- */ /* start CHOLMOD and set parameters */ /* ---------------------------------------------------------------------- */ cm = &Common ; cholmod_l_start (cm) ; sputil_config (SPUMONI, cm) ; /* ---------------------------------------------------------------------- */ /* check inputs */ /* ---------------------------------------------------------------------- */ if (nargout > 1 || nargin < 3 || nargin > 4) { mexErrMsgTxt ("Usage: L = ldlrowupdate (k, L, R, '+')") ; } n = mxGetN (pargin [1]) ; k = mxGetN (pargin [2]) ; if (!mxIsSparse (pargin [1]) || !mxIsSparse (pargin [2]) || n != mxGetM (pargin [1]) || n != mxGetM (pargin [2]) || mxIsComplex (pargin [1]) || mxIsComplex (pargin [2])) { k = mxGetM (pargin [2]); j = mxGetM (pargin [1]); printf("n=%d L=%d R=%d \n", n, j, k); mexErrMsgTxt ("ldlrowupdate: R and/or L not sparse, complex, or wrong" " dimensions") ; } /* ---------------------------------------------------------------------- */ /* determine if we're doing an update or downdate */ /* ---------------------------------------------------------------------- */ update = TRUE ; if (nargin > 3 && mxIsChar (pargin [3])) { mxGetString (pargin [3], buf, LEN) ; if (buf [0] == '-') { update = FALSE ; } else if (buf [0] != '+') { mexErrMsgTxt ("ldlrowupdate: update string must be '+' or '-'") ; } } /* ---------------------------------------------------------------------- */ /* get ki: column integer of update */ /* ---------------------------------------------------------------------- */ ki = (int) *mxGetPr(pargin[0]); ki = ki-1; /* ---------------------------------------------------------------------- */ /* get R: sparse matrix of incoming/outgoing columns */ /* ---------------------------------------------------------------------- */ R = sputil_get_sparse (pargin [2], &Cmatrix, &dummy, 0) ; /* ---------------------------------------------------------------------- */ /* construct a copy of the input sparse matrix L */ /* ---------------------------------------------------------------------- */ /* get the MATLAB L */ Lp = (Int *) mxGetJc (pargin [1]) ; Li = (Int *) mxGetIr (pargin [1]) ; Lx = mxGetPr (pargin [1]) ; /* allocate the CHOLMOD symbolic L */ L = cholmod_l_allocate_factor (n, cm) ; L->ordering = CHOLMOD_NATURAL ; ColCount = L->ColCount ; for (j = 0 ; j < n ; j++) { ColCount [j] = Lp [j+1] - Lp [j] ; } /* allocate space for a CHOLMOD LDL' packed factor */ cholmod_l_change_factor (CHOLMOD_REAL, FALSE, FALSE, TRUE, TRUE, L, cm) ; /* copy MATLAB L into CHOLMOD L */ Lp2 = L->p ; Li2 = L->i ; Lx2 = L->x ; Lnz2 = L->nz ; lnz = L->nzmax ; for (j = 0 ; j <= n ; j++) { Lp2 [j] = Lp [j] ; } for (j = 0 ; j < n ; j++) { Lnz2 [j] = Lp [j+1] - Lp [j] ; } for (s = 0 ; s < lnz ; s++) { Li2 [s] = Li [s] ; } for (s = 0 ; s < lnz ; s++) { Lx2 [s] = Lx [s] ; } /* ---------------------------------------------------------------------- */ /* update/downdate the LDL' factorization */ /* ---------------------------------------------------------------------- */ /* add row */ if (update){ if (!cholmod_l_rowadd (ki, R, L, cm)) { mexErrMsgTxt ("rowadd failed\n") ; } } /* delete row */ else { if (!cholmod_l_rowdel (ki, NULL, L, cm)) { mexErrMsgTxt ("rowdel failed\n") ; } } /* ---------------------------------------------------------------------- */ /* copy the results back to MATLAB */ /* ---------------------------------------------------------------------- */ /* change L back to packed LDL' (it may have become unpacked if the * sparsity pattern changed). This change takes O(n) time if the pattern * of L wasn't updated. */ Lsparse = cholmod_l_factor_to_sparse (L, cm) ; /* return L as a sparse matrix */ pargout [0] = sputil_put_sparse (&Lsparse, cm) ; /* ---------------------------------------------------------------------- */ /* free workspace and the CHOLMOD L, except for what is copied to MATLAB */ /* ---------------------------------------------------------------------- */ cholmod_l_free_factor (&L, cm) ; cholmod_l_finish (cm) ; cholmod_l_print_common (" ", cm) ; /* if (cm->malloc_count != 3 + mxIsComplex (pargout[0])) mexErrMsgTxt ("!") ; */ }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { double dummy = 0, beta [2], *px, *C, *Ct, *C2, *fil, *Zt, *zt, done=1.0, *zz, dzero=0.0; cholmod_sparse Amatrix, *A, *Lsparse ; cholmod_factor *L ; cholmod_common Common, *cm ; Int minor, *It2, *Jt2 ; mwIndex l, k2, h, k, i, j, ik, *I, *J, *Jt, *It, *I2, *J2, lfi, *w, *w2, *r; mwSize nnz, nnzlow, m, n; int nz = 0; mwSignedIndex one=1, lfi_si; mxArray *Am, *Bm; char *uplo="L", *trans="N"; /* ---------------------------------------------------------------------- */ /* Only one input. We have to find first the Cholesky factorization. */ /* start CHOLMOD and set parameters */ /* ---------------------------------------------------------------------- */ if (nargin == 1) { cm = &Common ; cholmod_l_start (cm) ; sputil_config (SPUMONI, cm) ; /* convert to packed LDL' when done */ cm->final_asis = FALSE ; cm->final_super = FALSE ; cm->final_ll = FALSE ; cm->final_pack = TRUE ; cm->final_monotonic = TRUE ; /* since numerically zero entries are NOT dropped from the symbolic * pattern, we DO need to drop entries that result from supernodal * amalgamation. */ cm->final_resymbol = TRUE ; cm->quick_return_if_not_posdef = (nargout < 2) ; } /* This will disable the supernodal LL', which will be slow. */ /* cm->supernodal = CHOLMOD_SIMPLICIAL ; */ /* ---------------------------------------------------------------------- */ /* get inputs */ /* ---------------------------------------------------------------------- */ if (nargin > 3) { mexErrMsgTxt ("usage: Z = sinv(A), or Z = sinv(LD, 1)") ; } n = mxGetM (pargin [0]) ; m = mxGetM (pargin [0]) ; if (!mxIsSparse (pargin [0])) { mexErrMsgTxt ("A must be sparse") ; } if (n != mxGetN (pargin [0])) { mexErrMsgTxt ("A must be square") ; } /* Only one input. We have to find first the Cholesky factorization. */ if (nargin == 1) { /* get sparse matrix A, use tril(A) */ A = sputil_get_sparse (pargin [0], &Amatrix, &dummy, -1) ; A->stype = -1 ; /* use lower part of A */ beta [0] = 0 ; beta [1] = 0 ; /* ---------------------------------------------------------------------- */ /* analyze and factorize */ /* ---------------------------------------------------------------------- */ L = cholmod_l_analyze (A, cm) ; cholmod_l_factorize_p (A, beta, NULL, 0, L, cm) ; if (cm->status != CHOLMOD_OK) { mexErrMsgTxt ("matrix is not positive definite") ; } /* ---------------------------------------------------------------------- */ /* convert L to a sparse matrix */ /* ---------------------------------------------------------------------- */ Lsparse = cholmod_l_factor_to_sparse (L, cm) ; if (Lsparse->xtype == CHOLMOD_COMPLEX) { mexErrMsgTxt ("matrix is complex") ; } /* ---------------------------------------------------------------------- */ /* Set the sparse Cholesky factorization in Matlab format */ /* ---------------------------------------------------------------------- */ /*Am = sputil_put_sparse (&Lsparse, cm) ; I = mxGetIr(Am); J = mxGetJc(Am); C = mxGetPr(Am); nnz = mxGetNzmax(Am); */ It2 = Lsparse->i; Jt2 = Lsparse->p; Ct = Lsparse->x; nnz = (mwSize) Lsparse->nzmax; Am = mxCreateSparse(m, m, nnz, mxREAL) ; I = mxGetIr(Am); J = mxGetJc(Am); C = mxGetPr(Am); for (j = 0 ; j < n+1 ; j++) J[j] = (mwIndex) Jt2[j]; for ( i = 0 ; i < nnz ; i++) { I[i] = (mwIndex) It2[i]; C[i] = Ct[i]; } cholmod_l_free_sparse (&Lsparse, cm) ; /*FILE *out1 = fopen( "output1.txt", "w" ); if( out1 != NULL ) fprintf( out1, "Hello %d\n", nnz ); fclose (out1);*/ } else { /* The cholesky factorization is given as an input. */ /* We have to copy it into workspace */ It = mxGetIr(pargin [0]); Jt = mxGetJc(pargin [0]); Ct = mxGetPr(pargin [0]); nnz = mxGetNzmax(pargin [0]); Am = mxCreateSparse(m, m, nnz, mxREAL) ; I = mxGetIr(Am); J = mxGetJc(Am); C = mxGetPr(Am); for (j = 0 ; j < n+1 ; j++) J[j] = Jt[j]; for ( i = 0 ; i < nnz ; i++) { I[i] = It[i]; C[i] = Ct[i]; } } /* Evaluate the sparse inverse */ C[nnz-1] = 1.0/C[J[m-1]]; /* set the last element of sparse inverse */ fil = mxCalloc((mwSize)1,sizeof(double)); zt = mxCalloc((mwSize)1,sizeof(double)); Zt = mxCalloc((mwSize)1,sizeof(double)); zz = mxCalloc((mwSize)1,sizeof(double)); for (j=m-2;j!=-1;j--){ lfi = J[j+1]-(J[j]+1); /* if (lfi > 0) */ if ( J[j+1] > (J[j]+1) ) { /* printf("lfi = %u \n ", lfi); printf("lfi*double = %u \n", (mwSize)lfi*sizeof(double)); printf("lfi*lfi*double = %u \n", (mwSize)lfi*(mwSize)lfi*sizeof(double)); printf("\n \n"); */ fil = mxRealloc(fil,(mwSize)lfi*sizeof(double)); for (i=0;i<lfi;i++) fil[i] = C[J[j]+i+1]; /* take the j'th lower triangular column of the Cholesky */ zt = mxRealloc(zt,(mwSize)lfi*sizeof(double)); /* memory for the sparse inverse elements to be evaluated */ Zt = mxRealloc(Zt,(mwSize)lfi*(mwSize)lfi*sizeof(double)); /* memory for the needed sparse inverse elements */ /* Set the lower triangular for Zt */ k2 = 0; for (k=J[j]+1;k<J[j+1];k++){ ik = I[k]; h = k2; for (l=J[ik];l<=J[ik+1];l++){ if (I[l] == I[ J[j]+h+1 ]){ Zt[h+lfi*k2] = C[l]; h++; } } k2++; } /* evaluate zt = fil*Zt */ lfi_si = (mwSignedIndex) lfi; dsymv(uplo, &lfi_si, &done, Zt, &lfi_si, fil, &one, &dzero, zt, &one); /* Set the evaluated sparse inverse elements, zt, into C */ k=lfi-1; for (i = J[j+1]-1; i!=J[j] ; i--){ C[i] = -zt[k]; k--; } /* evaluate the j'th diagonal of sparse inverse */ dgemv(trans, &one, &lfi_si, &done, fil, &one, zt, &one, &dzero, zz, &one); C[J[j]] = 1.0/C[J[j]] + zz[0]; } else { /* evaluate the j'th diagonal of sparse inverse */ C[J[j]] = 1.0/C[J[j]]; } } /* Free the temporary variables */ mxFree(fil); mxFree(zt); mxFree(Zt); mxFree(zz); /* ---------------------------------------------------------------------- */ /* Permute the elements according to r(q) = 1:n */ /* Done only if the Cholesky was evaluated here */ /* ---------------------------------------------------------------------- */ if (nargin == 1) { Bm = mxCreateSparse(m, m, nnz, mxREAL) ; It = mxGetIr(Bm); Jt = mxGetJc(Bm); Ct = mxGetPr(Bm); /* Ct = C(r,r) */ r = (mwIndex *) L->Perm; /* fill reducing ordering */ w = mxCalloc(m,sizeof(mwIndex)); /* column counts of Am */ /* count entries in each column of Bm */ for (j=0; j<m; j++){ k = r ? r[j] : j ; /* column j of Bm is column k of Am */ for (l=J[j] ; l<J[j+1] ; l++){ i = I[l]; ik = r ? r[i] : i ; /* row i of Bm is row ik of Am */ w[ max(ik,k) ]++; } } cumsum2(Jt, w, m); for (j=0; j<m; j++){ k = r ? r[j] : j ; /* column j of Bm is column k of Am */ for (l=J[j] ; l<J[j+1] ; l++){ i= I[l]; ik = r ? r[i] : i ; /* row i of Bm is row ik of Am */ It [k2 = w[max(ik,k)]++ ] = min(ik,k); Ct[k2] = C[l]; } } mxFree(w); /* ---------------------------------------------------------------------- */ /* Transpose the permuted (upper triangular) matrix Bm into Am */ /* (this way we get sorted columns) */ /* ---------------------------------------------------------------------- */ w = mxCalloc(m,sizeof(mwIndex)); for (i=0 ; i<Jt[m] ; i++) w[It[i]]++; /* row counts of Bm */ cumsum2(J, w, m); /* row pointers */ for (j=0 ; j<m ; j++){ for (i=Jt[j] ; i<Jt[j+1] ; i++){ I[ l=w[ It[i] ]++ ] = j; C[l] = Ct[i]; } } mxFree(w); mxDestroyArray(Bm); } /* ---------------------------------------------------------------------- */ /* Fill the upper triangle of the sparse inverse */ /* ---------------------------------------------------------------------- */ w = mxCalloc(m,sizeof(mwIndex)); /* workspace */ w2 = mxCalloc(m,sizeof(mwIndex)); /* workspace */ for (k=0;k<J[m];k++) w[I[k]]++; /* row counts of the lower triangular */ for (k=0;k<m;k++) w2[k] = w[k] + J[k+1] - J[k] - 1; /* column counts of the sparse inverse */ nnz = (mwSize)2*nnz - m; /* The number of nonzeros in Z */ pargout[0] = mxCreateSparse(m,m,nnz,mxREAL); /* The sparse matrix */ It = mxGetIr(pargout[0]); Jt = mxGetJc(pargout[0]); Ct = mxGetPr(pargout[0]); cumsum2(Jt, w2, m); /* column starting points */ for (j = 0 ; j < m ; j++){ /* fill the upper triangular */ for (k = J[j] ; k < J[j+1] ; k++){ It[l = w2[ I[k]]++] = j ; /* place C(i,j) as entry Ct(j,i) */ if (Ct) Ct[l] = C[k] ; } } for (j = 0 ; j < m ; j++){ /* fill the lower triangular */ for (k = J[j]+1 ; k < J[j+1] ; k++){ It[l = w2[j]++] = I[k] ; /* place C(j,i) as entry Ct(j,i) */ if (Ct) Ct[l] = C[k] ; } } mxFree(w2); mxFree(w); /* ---------------------------------------------------------------------- */ /* return to MATLAB */ /* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */ /* free workspace and the CHOLMOD L, except for what is copied to MATLAB */ /* ---------------------------------------------------------------------- */ if (nargin == 1) { cholmod_l_free_factor (&L, cm) ; cholmod_l_finish (cm) ; cholmod_l_print_common (" ", cm) ; } mxDestroyArray(Am); }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { double dummy = 0 ; double *Lx, *Lx2, *Lz, *Lz2 ; Long *Li, *Lp, *Lnz2, *Li2, *Lp2, *ColCount ; cholmod_sparse *A, Amatrix, *Lsparse, *S ; cholmod_factor *L ; cholmod_common Common, *cm ; Long j, s, n, lnz, is_complex ; /* ---------------------------------------------------------------------- */ /* start CHOLMOD and set parameters */ /* ---------------------------------------------------------------------- */ cm = &Common ; cholmod_l_start (cm) ; sputil_config (SPUMONI, cm) ; /* ---------------------------------------------------------------------- */ /* check inputs */ /* ---------------------------------------------------------------------- */ if (nargout > 1 || nargin != 2) { mexErrMsgTxt ("usage: L = resymbol (L, A)\n") ; } n = mxGetN (pargin [0]) ; if (!mxIsSparse (pargin [0]) || n != mxGetM (pargin [0])) { mexErrMsgTxt ("resymbol: L must be sparse and square") ; } if (n != mxGetM (pargin [1]) || n != mxGetN (pargin [1])) { mexErrMsgTxt ("resymbol: A and L must have same dimensions") ; } /* ---------------------------------------------------------------------- */ /* get the sparse matrix A */ /* ---------------------------------------------------------------------- */ A = sputil_get_sparse_pattern (pargin [1], &Amatrix, &dummy, cm) ; S = (A == &Amatrix) ? NULL : A ; A->stype = -1 ; /* A = sputil_get_sparse (pargin [1], &Amatrix, &dummy, -1) ; */ /* ---------------------------------------------------------------------- */ /* construct a copy of the input sparse matrix L */ /* ---------------------------------------------------------------------- */ /* get the MATLAB L */ Lp = (Long *) mxGetJc (pargin [0]) ; Li = (Long *) mxGetIr (pargin [0]) ; Lx = mxGetPr (pargin [0]) ; Lz = mxGetPi (pargin [0]) ; is_complex = mxIsComplex (pargin [0]) ; /* allocate the CHOLMOD symbolic L */ L = cholmod_l_allocate_factor (n, cm) ; L->ordering = CHOLMOD_NATURAL ; ColCount = L->ColCount ; for (j = 0 ; j < n ; j++) { ColCount [j] = Lp [j+1] - Lp [j] ; } /* allocate space for a CHOLMOD LDL' packed factor */ /* (LL' and LDL' are treated identically) */ cholmod_l_change_factor (is_complex ? CHOLMOD_ZOMPLEX : CHOLMOD_REAL, FALSE, FALSE, TRUE, TRUE, L, cm) ; /* copy MATLAB L into CHOLMOD L */ Lp2 = L->p ; Li2 = L->i ; Lx2 = L->x ; Lz2 = L->z ; Lnz2 = L->nz ; lnz = L->nzmax ; for (j = 0 ; j <= n ; j++) { Lp2 [j] = Lp [j] ; } for (j = 0 ; j < n ; j++) { Lnz2 [j] = Lp [j+1] - Lp [j] ; } for (s = 0 ; s < lnz ; s++) { Li2 [s] = Li [s] ; } for (s = 0 ; s < lnz ; s++) { Lx2 [s] = Lx [s] ; } if (is_complex) { for (s = 0 ; s < lnz ; s++) { Lz2 [s] = Lz [s] ; } } /* ---------------------------------------------------------------------- */ /* resymbolic factorization */ /* ---------------------------------------------------------------------- */ cholmod_l_resymbol (A, NULL, 0, TRUE, L, cm) ; /* ---------------------------------------------------------------------- */ /* copy the results back to MATLAB */ /* ---------------------------------------------------------------------- */ Lsparse = cholmod_l_factor_to_sparse (L, cm) ; /* return L as a sparse matrix */ pargout [0] = sputil_put_sparse (&Lsparse, cm) ; /* ---------------------------------------------------------------------- */ /* free workspace and the CHOLMOD L, except for what is copied to MATLAB */ /* ---------------------------------------------------------------------- */ cholmod_l_free_factor (&L, cm) ; cholmod_l_free_sparse (&S, cm) ; cholmod_l_finish (cm) ; cholmod_l_print_common (" ", cm) ; /* if (cm->malloc_count != 3 + mxIsComplex (pargout[0])) mexErrMsgTxt ("!") ; */ }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { double dummy = 0 ; double *Lx, *Lx2 ; Long *Li, *Lp, *Li2, *Lp2, *Lnz2, *ColCount ; cholmod_sparse Cmatrix, *C, *Lsparse ; cholmod_factor *L ; cholmod_common Common, *cm ; Long j, k, s, rowadd, n, lnz, ok ; /* ---------------------------------------------------------------------- */ /* start CHOLMOD and set parameters */ /* ---------------------------------------------------------------------- */ cm = &Common ; cholmod_l_start (cm) ; sputil_config (SPUMONI, cm) ; /* ---------------------------------------------------------------------- */ /* check inputs */ /* ---------------------------------------------------------------------- */ if (nargout > 1 || nargin < 2 || nargin > 3) { mexErrMsgTxt ("Usage: LD = ldlrowmod (LD,k,C) or ldlrowmod (LD,k)") ; } n = mxGetN (pargin [0]) ; k = (Long) mxGetScalar (pargin [1]) ; k = k - 1 ; /* change from 1-based to 0-based */ if (!mxIsSparse (pargin [0]) || n != mxGetM (pargin [0]) || mxIsComplex (pargin [0])) { mexErrMsgTxt ("ldlrowmod: L must be real, square, and sparse") ; } /* ---------------------------------------------------------------------- */ /* determine if we're doing an rowadd or rowdel */ /* ---------------------------------------------------------------------- */ rowadd = (nargin > 2) ; if (rowadd) { if (!mxIsSparse (pargin [2]) || n != mxGetM (pargin [2]) || 1 != mxGetN (pargin [2]) || mxIsComplex (pargin [2])) { mexErrMsgTxt ("ldlrowmod: C must be a real sparse vector, " "with the same number of rows as LD") ; } } /* ---------------------------------------------------------------------- */ /* get C: sparse vector of incoming/outgoing column */ /* ---------------------------------------------------------------------- */ C = (rowadd) ? sputil_get_sparse (pargin [2], &Cmatrix, &dummy, 0) : NULL ; /* ---------------------------------------------------------------------- */ /* construct a copy of the input sparse matrix L */ /* ---------------------------------------------------------------------- */ /* get the MATLAB L */ Lp = (Long *) mxGetJc (pargin [0]) ; Li = (Long *) mxGetIr (pargin [0]) ; Lx = mxGetPr (pargin [0]) ; /* allocate the CHOLMOD symbolic L */ L = cholmod_l_allocate_factor (n, cm) ; L->ordering = CHOLMOD_NATURAL ; ColCount = L->ColCount ; for (j = 0 ; j < n ; j++) { ColCount [j] = Lp [j+1] - Lp [j] ; } /* allocate space for a CHOLMOD LDL' packed factor */ cholmod_l_change_factor (CHOLMOD_REAL, FALSE, FALSE, TRUE, TRUE, L, cm) ; /* copy MATLAB L into CHOLMOD L */ Lp2 = L->p ; Li2 = L->i ; Lx2 = L->x ; Lnz2 = L->nz ; lnz = L->nzmax ; for (j = 0 ; j <= n ; j++) { Lp2 [j] = Lp [j] ; } for (j = 0 ; j < n ; j++) { Lnz2 [j] = Lp [j+1] - Lp [j] ; } for (s = 0 ; s < lnz ; s++) { Li2 [s] = Li [s] ; } for (s = 0 ; s < lnz ; s++) { Lx2 [s] = Lx [s] ; } /* ---------------------------------------------------------------------- */ /* rowadd/rowdel the LDL' factorization */ /* ---------------------------------------------------------------------- */ if (rowadd) { ok = cholmod_l_rowadd (k, C, L, cm) ; } else { ok = cholmod_l_rowdel (k, NULL, L, cm) ; } if (!ok) mexErrMsgTxt ("ldlrowmod failed\n") ; /* ---------------------------------------------------------------------- */ /* copy the results back to MATLAB */ /* ---------------------------------------------------------------------- */ /* change L back to packed LDL' (it may have become unpacked if the * sparsity pattern changed). This change takes O(n) time if the pattern * of L wasn't updated. */ Lsparse = cholmod_l_factor_to_sparse (L, cm) ; /* return L as a sparse matrix */ pargout [0] = sputil_put_sparse (&Lsparse, cm) ; /* ---------------------------------------------------------------------- */ /* free workspace and the CHOLMOD L, except for what is copied to MATLAB */ /* ---------------------------------------------------------------------- */ cholmod_l_free_factor (&L, cm) ; cholmod_l_finish (cm) ; cholmod_l_print_common (" ", cm) ; /* if (cm->malloc_count != 3 + mxIsComplex (pargout[0])) mexErrMsgTxt ("!") ; */ }