14 A->
m = INTEGER(dim)[0];
15 A->
n = INTEGER(dim)[1];
21 if (values && x != R_NilValue) {
43 error(
_(
"wrong '%s'"),
"xtype");
44 char cl[] =
"..CMatrix";
49 R_xlen_t np1 = (R_xlen_t) A->
n + 1;
52 p = PROTECT(allocVector(INTSXP, np1)),
53 i = PROTECT(allocVector(INTSXP, nnz));
54 INTEGER(dim)[0] = A->
m;
55 INTEGER(dim)[1] = A->
n;
63 PROTECT(x = allocVector(CPLXSXP, nnz));
66 PROTECT(x = allocVector(REALSXP, nnz));
82 return (
Matrix_csd *) cs_ci_dfree((cs_cid *) D);
84 return (
Matrix_csd *) cs_di_dfree((cs_did *) D);
94 return (
Matrix_csd *) cs_ci_dmperm((cs_ci *) A, seed);
96 return (
Matrix_csd *) cs_di_dmperm((cs_di *) A, seed);
98 return (
Matrix_csd *) cs_dmperm((cs *) A, seed);
106 return cs_ci_dropzeros((cs_ci *) A);
108 return cs_di_dropzeros((cs_di *) A);
110 return cs_dropzeros((cs *) A);
118 return cs_ci_free(p);
120 return cs_di_free(p);
130 return cs_ci_happly((cs_ci *) V, i, beta, (
double _Complex *) x);
132 return cs_di_happly((cs_di *) V, i, beta, (
double *) x);
134 return cs_happly((cs *) V, i, beta, (
double *) x);
142 return cs_ci_ipvec(p, (
double _Complex *) b, (
double _Complex *) x, n);
144 return cs_di_ipvec(p, (
double *) b, (
double *) x, n);
146 return cs_ipvec(p, (
double *) b, (
double *) x, n);
154 return cs_ci_lsolve((cs_ci *) L, (
double _Complex *) x);
156 return cs_di_lsolve((cs_di *) L, (
double *) x);
158 return cs_lsolve((cs *) L, (
double *) x);
166 return (
Matrix_csn *) cs_ci_lu((cs_ci *) A, (cs_cis *) S, tol);
168 return (
Matrix_csn *) cs_di_lu((cs_di *) A, (cs_dis *) S, tol);
170 return (
Matrix_csn *) cs_lu((cs *) A, (css *) S, tol);
178 return cs_ci_lusol(order, (cs_ci *) A, (
double _Complex *) b, tol);
180 return cs_di_lusol(order, (cs_di *) A, (
double *) b, tol);
182 return cs_lusol(order, (cs *) A, (
double *) b, tol);
190 return (
Matrix_csn *) cs_ci_nfree((cs_cin *) N);
192 return (
Matrix_csn *) cs_di_nfree((cs_din *) N);
203 cs_ci *tmp = cs_ci_permute((cs_ci *) A, pinv, q, values);
205 memcpy(B, tmp,
sizeof(cs_ci));
206 tmp = cs_ci_free(tmp);
208 cs_di *tmp = cs_di_permute((cs_di *) A, pinv, q, values);
210 memcpy(B, tmp,
sizeof(cs_di));
211 tmp = cs_di_free(tmp);
214 cs *tmp = cs_permute((cs *) A, pinv, q, values);
216 memcpy(B, tmp,
sizeof(cs ));
227 return cs_ci_pinv(p, n);
229 return cs_di_pinv(p, n);
231 return cs_pinv(p, n);
239 return cs_ci_pvec(p, (
double _Complex *) b, (
double _Complex *) x, n);
241 return cs_di_pvec(p, (
double *) b, (
double *) x, n);
243 return cs_pvec(p, (
double *) b, (
double *) x, n);
251 return (
Matrix_csn *) cs_ci_qr((cs_ci *) A, (cs_cis *) S);
253 return (
Matrix_csn *) cs_di_qr((cs_di *) A, (cs_dis *) S);
255 return (
Matrix_csn *) cs_qr((cs *) A, (css *) S);
263 return cs_ci_qrsol(order, (cs_ci *) A, (
double _Complex *) b);
265 return cs_di_qrsol(order, (cs_di *) A, (
double *) b);
267 return cs_qrsol(order, (cs *) A, (
double *) b);
275 return (
Matrix_css *) cs_ci_sfree((cs_cis *) S);
277 return (
Matrix_css *) cs_di_sfree((cs_dis *) S);
288 cs_ci *tmp = cs_ci_spalloc(m, n, nzmax, values, triplet);
290 memcpy(B, tmp,
sizeof(cs_ci));
291 tmp = cs_ci_free(tmp);
293 cs_di *tmp = cs_di_spalloc(m, n, nzmax, values, triplet);
295 memcpy(B, tmp,
sizeof(cs_di));
296 tmp = cs_di_free(tmp);
299 cs *tmp = cs_spalloc(m, n, nzmax, values, triplet);
301 memcpy(B, tmp,
sizeof(cs ));
310 int k, d = (m < n) ? m : n;
314 int *B__p = B->
p, *B__i = B->
i;
315 for (k = 0; k < d; ++k)
316 B__p[k] = B__i[k] = k;
318 for (k = d; k <= n; ++k)
323 double _Complex *B__x = (
double _Complex *) B->
x;
324 for (k = 0; k < d; ++k)
328 double *B__x = (
double *) B->
x;
329 for (k = 0; k < d; ++k)
342 return (
Matrix_cs *) cs_ci_spfree((cs_ci *) A);
344 return (
Matrix_cs *) cs_di_spfree((cs_di *) A);
346 return (
Matrix_cs *) cs_spfree((cs *) A);
354 return cs_ci_sprealloc((cs_ci *) A, nzmax);
356 return cs_di_sprealloc((cs_di *) A, nzmax);
358 return cs_sprealloc((cs *) A, nzmax);
366 return cs_ci_spsolve((cs_ci *) L, (cs_ci *) B, k, xi, (
double _Complex *) x, pinv, lo);
368 return cs_di_spsolve((cs_di *) L, (cs_di *) B, k, xi, (
double *) x, pinv, lo);
370 return cs_spsolve((cs *) L, (cs *) B, k, xi, (
double *) x, pinv, lo);
378 return (
Matrix_css *) cs_ci_sqr(order, (cs_ci *) A, qr);
380 return (
Matrix_css *) cs_di_sqr(order, (cs_di *) A, qr);
382 return (
Matrix_css *) cs_sqr(order, (cs *) A, qr);
391 cs_ci *tmp = cs_ci_transpose((cs_ci *) A, values);
393 memcpy(B, tmp,
sizeof(cs_ci));
394 tmp = cs_ci_free(tmp);
396 cs_di *tmp = cs_di_transpose((cs_di *) A, values);
398 memcpy(B, tmp,
sizeof(cs_di));
399 tmp = cs_di_free(tmp);
402 cs *tmp = cs_transpose((cs *) A, values);
404 memcpy(B, tmp,
sizeof(cs ));
415 return cs_ci_usolve((cs_ci *) U, (
double _Complex *) x);
417 return cs_di_usolve((cs_di *) U, (
double *) x);
419 return cs_usolve((cs *) U, (
double *) x);
#define ERROR_INVALID_TYPE(_X_, _FUNC_)
#define SET_SLOT(x, what, value)
#define GET_SLOT(x, what)
SEXP newObject(const char *)
int Matrix_cs_lsolve(const Matrix_cs *L, void *x)
Matrix_cs * Matrix_cs_transpose(const Matrix_cs *A, int values)
Matrix_cs * Matrix_cs_spfree(Matrix_cs *A)
Matrix_csn * Matrix_cs_lu(const Matrix_cs *A, const Matrix_css *S, double tol)
int Matrix_cs_usolve(const Matrix_cs *U, void *x)
int Matrix_cs_qrsol(int order, const Matrix_cs *A, void *b)
void * Matrix_cs_free(void *p)
int Matrix_cs_ipvec(const int *p, const void *b, void *x, int n)
Matrix_cs * Matrix_cs_permute(const Matrix_cs *A, const int *pinv, const int *q, int values)
Matrix_csn * Matrix_cs_qr(const Matrix_cs *A, const Matrix_css *S)
Matrix_csd * Matrix_cs_dmperm(const Matrix_cs *A, int seed)
SEXP CXS2M(Matrix_cs *A, int values, char shape)
int Matrix_cs_lusol(int order, const Matrix_cs *A, void *b, double tol)
Matrix_csd * Matrix_cs_dfree(Matrix_csd *D)
int Matrix_cs_happly(const Matrix_cs *V, int i, double beta, void *x)
Matrix_css * Matrix_cs_sfree(Matrix_css *S)
Matrix_cs * Matrix_cs_speye(int m, int n, int values, int triplet)
int * Matrix_cs_pinv(const int *p, int n)
int Matrix_cs_sprealloc(Matrix_cs *A, int nzmax)
Matrix_cs * Matrix_cs_spalloc(int m, int n, int nzmax, int values, int triplet)
int Matrix_cs_dropzeros(Matrix_cs *A)
int Matrix_cs_spsolve(Matrix_cs *L, const Matrix_cs *B, int k, int *xi, void *x, const int *pinv, int lo)
Matrix_css * Matrix_cs_sqr(int order, const Matrix_cs *A, int qr)
Matrix_cs * M2CXS(SEXP obj, int values)
Matrix_csn * Matrix_cs_nfree(Matrix_csn *N)
int Matrix_cs_pvec(const int *p, const void *b, void *x, int n)
void * Matrix_memcpy(void *dest, const void *src, R_xlen_t length, size_t size)