The R Project SVN – R-packages – Diff – /branches/Matrix-APIchange/src/dsCMatrix.c

 #include "dsCMatrix.h"
 SEXP dsCMatrix_chol(SEXP x, SEXP pivot)
+{
-    cholmod_factor
-	*N = as_cholmod_factor(dsCMatrix_Cholesky(x, pivot,
+    CHM_FR N = AS_CHM_FR(dsCMatrix_Cholesky(x, pivot, ScalarLogical(FALSE),
-						  ScalarLogical(FALSE),
-						  ScalarLogical(FALSE)));
+					    ScalarLogical(FALSE)));
     /* Must use a copy; cholmod_factor_to_sparse modifies first arg. */
-    cholmod_factor *Ncp = cholmod_copy_factor(N, &c);
+    CHM_FR Ncp = cholmod_copy_factor(N, &c);
-    cholmod_sparse *L, *R;
-    SEXP ans;
-    L = cholmod_factor_to_sparse(Ncp, &c); cholmod_free_factor(&Ncp, &c);
+    CHM_SP L = cholmod_factor_to_sparse(Ncp, &c);
-    R = cholmod_transpose(L, /*values*/ 1, &c); cholmod_free_sparse(&L, &c);
+    CHM_SP R = cholmod_transpose(L, /*values*/ 1, &c);
-    ans = PROTECT(chm_sparse_to_SEXP(R, /*cholmod_free*/ 1,
+    SEXP ans = PROTECT(chm_sparse_to_SEXP(R, 1/*do_free*/, 1/*uploT*/, 0/*Rkind*/,
-				     /*uploT*/ 1, /*Rkind*/ 0, /*diag*/ "N",
+					  "N"/*diag*/, GET_SLOT(x, Matrix_DimNamesSym)));
-				     GET_SLOT(x, Matrix_DimNamesSym)));
+    cholmod_free_factor(&Ncp, &c);
+    cholmod_free_sparse(&L, &c);
     if (asLogical(pivot)) {
 	SEXP piv = PROTECT(allocVector(INTSXP, N->n));
 	int *dest = INTEGER(piv), *src = (int*)N->Perm, i;
 	for (i = 0; i < N->n; i++) dest[i] = src[i] + 1;
 	 * chm_factor_to_SEXP to keep track of Minor.
 	 */
 	setAttrib(ans, install("rank"), ScalarInteger((size_t) N->minor));
 	UNPROTECT(1);
+    }
-    Free(N);
     UNPROTECT(1);
     return ans;
+}
 SEXP dsCMatrix_Cholesky(SEXP Ap, SEXP permP, SEXP LDLp, SEXP superP)
     char fname[12] = "spdCholesky"; /* template for factorization name */
     /* S|s : super or not
      * P|p : permuted or not
      * D|d :  LDL' or not (= LL')
      */
-    int perm = asLogical(permP),
+    int perm = asLogical(permP), LDL = asLogical(LDLp), super = asLogical(superP);
-	LDL = asLogical(LDLp),
-	super = asLogical(superP);
     SEXP Chol;
-    cholmod_sparse *A;
+    CHM_SP A;
-    cholmod_factor *L;
+    CHM_FR L;
     int sup, ll;
     if (super) fname[0] = 'S';
     if (perm) fname[1] = 'P';
     if (LDL) fname[2] = 'D';
     Chol = get_factors(Ap, fname);
-    /* If Ap has already cached the factor, we return it immediately */
-    if (Chol != R_NilValue) return Chol;
+    if (Chol != R_NilValue) return Chol; /* return a cached factor */
-    A = as_cholmod_sparse(Ap);
+    A = AS_CHM_SP(Ap);
     if (!A->stype)
 	error("Non-symmetric matrix passed to dsCMatrix_chol");
     sup = c.supernodal;
     ll = c.final_ll;
+    }
     if (!cholmod_factorize(A, L, &c))
 	error(_("Cholesky factorization failed"));
     c.supernodal = sup;	/* restore previous setting */
     c.final_ll = ll;
-    Free(A);
     Chol = set_factors(Ap, chm_factor_to_SEXP(L, 1), fname);
     return Chol;
+}
 static
+}
 SEXP dsCMatrix_Csparse_solve(SEXP a, SEXP b)
+{
     SEXP Chol = get_factor_pattern(a, "...Cholesky", 3);
-    cholmod_factor *L;
+    CHM_FR L;
-    cholmod_sparse *cx, *cb = as_cholmod_sparse(b);
+    CHM_SP cx, cb = AS_CHM_SP(b);
     if (Chol == R_NilValue) /* compute (and cache) "sPDCholesky" */
 	Chol = dsCMatrix_Cholesky(a,
 				  ScalarLogical(1),  /* permuted  : "P" */
 				  ScalarLogical(1),  /* LDL'	  : "D" */
 				  ScalarLogical(0)); /* simplicial: "s" */
-    L = as_cholmod_factor(Chol);
+    L = AS_CHM_FR(Chol);
     cx = cholmod_spsolve(CHOLMOD_A, L, cb, &c);
-    Free(cb); Free(L);
-    return chm_sparse_to_SEXP(cx, /*cholmod_free*/ 1, /*uploT*/ 0,
+    return chm_sparse_to_SEXP(cx, /*do_free*/ 1, /*uploT*/ 0,
 			      /*Rkind*/ 0, /*diag*/ "N",
 			      /*dimnames = */ R_NilValue);
+}
 SEXP dsCMatrix_matrix_solve(SEXP a, SEXP b)
+{
     SEXP Chol = get_factor_pattern(a, "...Cholesky", 3);
-    cholmod_factor *L;
+    CHM_FR L;
-    cholmod_dense  *cx,
-	*cb = as_cholmod_dense(PROTECT(mMatrix_as_dgeMatrix(b)));
+    CHM_DN cx, cb = AS_CHM_DN(PROTECT(mMatrix_as_dgeMatrix(b)));
     if (Chol == R_NilValue) /* compute (and cache) "sPDCholesky" */
 	Chol = dsCMatrix_Cholesky(a,
 				  ScalarLogical(1),  /* permuted  : "P" */
 				  ScalarLogical(1),  /* LDL'      : "D" */
 				  ScalarLogical(0)); /* simplicial: "s" */
-    L = as_cholmod_factor(Chol);
+    L = AS_CHM_FR(Chol);
     cx = cholmod_solve(CHOLMOD_A, L, cb, &c);
-    Free(cb); Free(L);
     UNPROTECT(1);
     return chm_dense_to_SEXP(cx, 1, 0, /*dimnames = */ R_NilValue);
+}
 /* Needed for printing dsCMatrix objects */
 /* FIXME: Create a more general version of this operation: also for lsC, (dsR?),..
 *         e.g. make  compressed_to_dgTMatrix() in ./dgCMatrix.c work for dsC */
 SEXP dsCMatrix_to_dgTMatrix(SEXP x)
+{
-    cholmod_sparse *A = as_cholmod_sparse(x);
+    CHM_SP A = AS_CHM_SP(x);
-    cholmod_sparse *Afull = cholmod_copy(A, /*stype*/ 0, /*mode*/ 1, &c);
+    CHM_SP Afull = cholmod_copy(A, /*stype*/ 0, /*mode*/ 1, &c);
-    cholmod_triplet *At = cholmod_sparse_to_triplet(Afull, &c);
+    CHM_TR At = cholmod_sparse_to_triplet(Afull, &c);
     if (!A->stype)
 	error("Non-symmetric matrix passed to dsCMatrix_to_dgTMatrix");
-    Free(A); cholmod_free_sparse(&Afull, &c);
+    cholmod_free_sparse(&Afull, &c);
     return chm_triplet_to_SEXP(At, 1, /*uploT*/ 0, /*Rkind*/ 0, "",
 			       GET_SLOT(x, Matrix_DimNamesSym));
+}

The R Project SVN R-packages

(root)/branches/Matrix-APIchange/src/dsCMatrix.c @ 4560 – Rev 4529 → 4530