/* call-seq:
* matrix * num -> IGraphMatrix
*
* Multiples two IGraphMatrix objects together
*/
VALUE cIGraph_matrix_scale(VALUE self, VALUE x){
igraph_matrix_t *m;
igraph_matrix_t *n = malloc(sizeof(igraph_matrix_t));
VALUE nobj;
Data_Get_Struct(self, igraph_matrix_t, m);
igraph_matrix_copy(n,m);
igraph_matrix_scale(n, NUM2DBL(x));
nobj = Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, n);
return nobj;
}
/* Document-method: initialize_copy
*
* Internal method for copying IGraph objects.
*/
VALUE cIGraph_matrix_init_copy(VALUE copy, VALUE orig){
igraph_matrix_t *orig_m;
igraph_matrix_t *copy_m;
if (copy == orig)
return copy;
if(TYPE(orig) != T_DATA || RDATA(orig)->dfree != (RUBY_DATA_FUNC)cIGraph_free){
rb_raise(rb_eTypeError, "Wrong argument type.");
}
Data_Get_Struct(copy, igraph_matrix_t, copy_m);
Data_Get_Struct(orig, igraph_matrix_t, orig_m);
igraph_matrix_copy(copy_m,orig_m);
return copy;
}
int igraph_lapack_dgehrd(const igraph_matrix_t *A,
int ilo, int ihi,
igraph_matrix_t *result) {
int n=(int) igraph_matrix_nrow(A);
int lda=n;
int lwork=-1;
igraph_vector_t work;
igraph_real_t optwork;
igraph_vector_t tau;
igraph_matrix_t Acopy;
int info=0;
int i;
if (igraph_matrix_ncol(A) != n) {
IGRAPH_ERROR("Hessenberg reduction failed", IGRAPH_NONSQUARE);
}
if (ilo < 1 || ihi > n || ilo > ihi) {
IGRAPH_ERROR("Invalid `ilo' and/or `ihi'", IGRAPH_EINVAL);
}
if (n <= 1) {
IGRAPH_CHECK(igraph_matrix_update(result, A));
return 0;
}
IGRAPH_CHECK(igraph_matrix_copy(&Acopy, A));
IGRAPH_FINALLY(igraph_matrix_destroy, &Acopy);
IGRAPH_VECTOR_INIT_FINALLY(&tau, n-1);
igraphdgehrd_(&n, &ilo, &ihi, &MATRIX(Acopy, 0, 0), &lda, VECTOR(tau),
&optwork, &lwork, &info);
if (info != 0) {
IGRAPH_ERROR("Internal Hessenberg transformation error",
IGRAPH_EINTERNAL);
}
lwork=(int) optwork;
IGRAPH_VECTOR_INIT_FINALLY(&work, lwork);
igraphdgehrd_(&n, &ilo, &ihi, &MATRIX(Acopy, 0, 0), &lda, VECTOR(tau),
VECTOR(work), &lwork, &info);
if (info != 0) {
IGRAPH_ERROR("Internal Hessenberg transformation error",
IGRAPH_EINTERNAL);
}
igraph_vector_destroy(&work);
igraph_vector_destroy(&tau);
IGRAPH_FINALLY_CLEAN(2);
IGRAPH_CHECK(igraph_matrix_update(result, &Acopy));
igraph_matrix_destroy(&Acopy);
IGRAPH_FINALLY_CLEAN(1);
for (i=0; i<n-2; i++) {
int j;
for (j=i+2; j<n; j++) {
MATRIX(*result, j, i) = 0.0;
}
}
return 0;
}
int igraph_lapack_dgeevx(igraph_lapack_dgeevx_balance_t balance,
const igraph_matrix_t *A,
igraph_vector_t *valuesreal,
igraph_vector_t *valuesimag,
igraph_matrix_t *vectorsleft,
igraph_matrix_t *vectorsright,
int *ilo, int *ihi, igraph_vector_t *scale,
igraph_real_t *abnrm,
igraph_vector_t *rconde,
igraph_vector_t *rcondv,
int *info) {
char balanc;
char jobvl= vectorsleft ? 'V' : 'N';
char jobvr= vectorsright ? 'V' : 'N';
char sense;
int n=(int) igraph_matrix_nrow(A);
int lda=n, ldvl=n, ldvr=n, lwork=-1;
igraph_vector_t work;
igraph_vector_int_t iwork;
igraph_matrix_t Acopy;
int error=*info;
igraph_vector_t *myreal=valuesreal, *myimag=valuesimag, vreal, vimag;
igraph_vector_t *myscale=scale, vscale;
if (igraph_matrix_ncol(A) != n) {
IGRAPH_ERROR("Cannot calculate eigenvalues (dgeevx)", IGRAPH_NONSQUARE);
}
switch (balance) {
case IGRAPH_LAPACK_DGEEVX_BALANCE_NONE:
balanc='N';
break;
case IGRAPH_LAPACK_DGEEVX_BALANCE_PERM:
balanc='P';
break;
case IGRAPH_LAPACK_DGEEVX_BALANCE_SCALE:
balanc='S';
break;
case IGRAPH_LAPACK_DGEEVX_BALANCE_BOTH:
balanc='B';
break;
default:
IGRAPH_ERROR("Invalid 'balance' argument", IGRAPH_EINVAL);
break;
}
if (!rconde && !rcondv) {
sense='N';
} else if (rconde && !rcondv) {
sense='E';
} else if (!rconde && rcondv) {
sense='V';
} else {
sense='B';
}
IGRAPH_CHECK(igraph_matrix_copy(&Acopy, A));
IGRAPH_FINALLY(igraph_matrix_destroy, &Acopy);
IGRAPH_VECTOR_INIT_FINALLY(&work, 1);
IGRAPH_CHECK(igraph_vector_int_init(&iwork, n));
IGRAPH_FINALLY(igraph_vector_int_destroy, &iwork);
if (!valuesreal) {
IGRAPH_VECTOR_INIT_FINALLY(&vreal, n);
myreal=&vreal;
} else {
IGRAPH_CHECK(igraph_vector_resize(myreal, n));
}
if (!valuesimag) {
IGRAPH_VECTOR_INIT_FINALLY(&vimag, n);
myimag=&vimag;
} else {
IGRAPH_CHECK(igraph_vector_resize(myimag, n));
}
if (!scale) {
IGRAPH_VECTOR_INIT_FINALLY(&vscale, n);
myscale=&vscale;
} else {
IGRAPH_CHECK(igraph_vector_resize(scale, n));
}
if (vectorsleft) {
IGRAPH_CHECK(igraph_matrix_resize(vectorsleft, n, n));
}
if (vectorsright) {
IGRAPH_CHECK(igraph_matrix_resize(vectorsright, n, n));
}
igraphdgeevx_(&balanc, &jobvl, &jobvr, &sense, &n, &MATRIX(Acopy,0,0),
&lda, VECTOR(*myreal), VECTOR(*myimag),
vectorsleft ? &MATRIX(*vectorsleft ,0,0) : 0, &ldvl,
vectorsright ? &MATRIX(*vectorsright,0,0) : 0, &ldvr,
ilo, ihi, VECTOR(*myscale), abnrm,
rconde ? VECTOR(*rconde) : 0,
rcondv ? VECTOR(*rcondv) : 0,
VECTOR(work), &lwork, VECTOR(iwork), info);
lwork=(int) VECTOR(work)[0];
IGRAPH_CHECK(igraph_vector_resize(&work, lwork));
igraphdgeevx_(&balanc, &jobvl, &jobvr, &sense, &n, &MATRIX(Acopy,0,0),
&lda, VECTOR(*myreal), VECTOR(*myimag),
vectorsleft ? &MATRIX(*vectorsleft ,0,0) : 0, &ldvl,
vectorsright ? &MATRIX(*vectorsright,0,0) : 0, &ldvr,
ilo, ihi, VECTOR(*myscale), abnrm,
rconde ? VECTOR(*rconde) : 0,
rcondv ? VECTOR(*rcondv) : 0,
VECTOR(work), &lwork, VECTOR(iwork), info);
if (*info < 0) {
IGRAPH_ERROR("Cannot calculate eigenvalues (dgeev)", IGRAPH_ELAPACK);
} else if (*info > 0) {
if (error) {
IGRAPH_ERROR("Cannot calculate eigenvalues (dgeev)", IGRAPH_ELAPACK);
} else {
IGRAPH_WARNING("Cannot calculate eigenvalues (dgeev)");
}
}
if (!scale) {
igraph_vector_destroy(&vscale);
IGRAPH_FINALLY_CLEAN(1);
}
if (!valuesimag) {
igraph_vector_destroy(&vimag);
IGRAPH_FINALLY_CLEAN(1);
}
if (!valuesreal) {
igraph_vector_destroy(&vreal);
IGRAPH_FINALLY_CLEAN(1);
}
igraph_vector_int_destroy(&iwork);
igraph_vector_destroy(&work);
igraph_matrix_destroy(&Acopy);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int igraph_lapack_dgeev(const igraph_matrix_t *A,
igraph_vector_t *valuesreal,
igraph_vector_t *valuesimag,
igraph_matrix_t *vectorsleft,
igraph_matrix_t *vectorsright,
int *info) {
char jobvl= vectorsleft ? 'V' : 'N';
char jobvr= vectorsright ? 'V' : 'N';
int n=(int) igraph_matrix_nrow(A);
int lda=n, ldvl=n, ldvr=n, lwork=-1;
igraph_vector_t work;
igraph_vector_t *myreal=valuesreal, *myimag=valuesimag, vreal, vimag;
igraph_matrix_t Acopy;
int error=*info;
if (igraph_matrix_ncol(A) != n) {
IGRAPH_ERROR("Cannot calculate eigenvalues (dgeev)", IGRAPH_NONSQUARE);
}
IGRAPH_CHECK(igraph_matrix_copy(&Acopy, A));
IGRAPH_FINALLY(igraph_matrix_destroy, &Acopy);
IGRAPH_VECTOR_INIT_FINALLY(&work, 1);
if (!valuesreal) {
IGRAPH_VECTOR_INIT_FINALLY(&vreal, n);
myreal=&vreal;
} else {
IGRAPH_CHECK(igraph_vector_resize(myreal, n));
}
if (!valuesimag) {
IGRAPH_VECTOR_INIT_FINALLY(&vimag, n);
myimag=&vimag;
} else {
IGRAPH_CHECK(igraph_vector_resize(myimag, n));
}
if (vectorsleft) {
IGRAPH_CHECK(igraph_matrix_resize(vectorsleft, n, n));
}
if (vectorsright) {
IGRAPH_CHECK(igraph_matrix_resize(vectorsright, n, n));
}
igraphdgeev_(&jobvl, &jobvr, &n, &MATRIX(Acopy,0,0), &lda,
VECTOR(*myreal), VECTOR(*myimag),
vectorsleft ? &MATRIX(*vectorsleft ,0,0) : 0, &ldvl,
vectorsright ? &MATRIX(*vectorsright,0,0) : 0, &ldvr,
VECTOR(work), &lwork, info);
lwork=(int) VECTOR(work)[0];
IGRAPH_CHECK(igraph_vector_resize(&work, lwork));
igraphdgeev_(&jobvl, &jobvr, &n, &MATRIX(Acopy,0,0), &lda,
VECTOR(*myreal), VECTOR(*myimag),
vectorsleft ? &MATRIX(*vectorsleft ,0,0) : 0, &ldvl,
vectorsright ? &MATRIX(*vectorsright,0,0) : 0, &ldvr,
VECTOR(work), &lwork, info);
if (*info < 0) {
IGRAPH_ERROR("Cannot calculate eigenvalues (dgeev)", IGRAPH_ELAPACK);
} else if (*info > 0) {
if (error) {
IGRAPH_ERROR("Cannot calculate eigenvalues (dgeev)", IGRAPH_ELAPACK);
} else {
IGRAPH_WARNING("Cannot calculate eigenvalues (dgeev)");
}
}
if (!valuesimag) {
igraph_vector_destroy(&vimag);
IGRAPH_FINALLY_CLEAN(1);
}
if (!valuesreal) {
igraph_vector_destroy(&vreal);
IGRAPH_FINALLY_CLEAN(1);
}
igraph_vector_destroy(&work);
igraph_matrix_destroy(&Acopy);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
int igraph_lapack_dsyevr(const igraph_matrix_t *A,
igraph_lapack_dsyev_which_t which,
igraph_real_t vl, igraph_real_t vu, int vestimate,
int il, int iu, igraph_real_t abstol,
igraph_vector_t *values, igraph_matrix_t *vectors,
igraph_vector_int_t *support) {
igraph_matrix_t Acopy;
char jobz = vectors ? 'V' : 'N', range, uplo='U';
int n=(int) igraph_matrix_nrow(A), lda=n, ldz=n;
int m, info;
igraph_vector_t *myvalues=values, vvalues;
igraph_vector_int_t *mysupport=support, vsupport;
igraph_vector_t work;
igraph_vector_int_t iwork;
int lwork=-1, liwork=-1;
if (n != igraph_matrix_ncol(A)) {
IGRAPH_ERROR("Cannot find eigenvalues/vectors", IGRAPH_NONSQUARE);
}
if (which==IGRAPH_LAPACK_DSYEV_INTERVAL &&
(vestimate < 1 || vestimate > n)) {
IGRAPH_ERROR("Estimated (upper bound) number of eigenvalues must be "
"between 1 and n", IGRAPH_EINVAL);
}
if (which==IGRAPH_LAPACK_DSYEV_SELECT && iu-il < 0) {
IGRAPH_ERROR("Invalid 'il' and/or 'iu' values", IGRAPH_EINVAL);
}
IGRAPH_CHECK(igraph_matrix_copy(&Acopy, A));
IGRAPH_FINALLY(igraph_matrix_destroy, &Acopy);
IGRAPH_VECTOR_INIT_FINALLY(&work, 1);
IGRAPH_CHECK(igraph_vector_int_init(&iwork, 1));
IGRAPH_FINALLY(igraph_vector_int_destroy, &iwork);
if (!values) {
IGRAPH_VECTOR_INIT_FINALLY(&vvalues, 0);
myvalues=&vvalues;
}
if (!support) {
IGRAPH_CHECK(igraph_vector_int_init(&vsupport, 0));
IGRAPH_FINALLY(igraph_vector_int_destroy, &vsupport);
mysupport=&vsupport;
}
switch (which) {
case IGRAPH_LAPACK_DSYEV_ALL:
range = 'A';
IGRAPH_CHECK(igraph_vector_resize(myvalues, n));
IGRAPH_CHECK(igraph_vector_int_resize(mysupport, 2*n));
if (vectors) { IGRAPH_CHECK(igraph_matrix_resize(vectors, n, n)); }
break;
case IGRAPH_LAPACK_DSYEV_INTERVAL:
range = 'V';
IGRAPH_CHECK(igraph_vector_resize(myvalues, vestimate));
IGRAPH_CHECK(igraph_vector_int_resize(mysupport, 2*vestimate));
if (vectors) { IGRAPH_CHECK(igraph_matrix_resize(vectors,n, vestimate)); }
break;
case IGRAPH_LAPACK_DSYEV_SELECT:
range = 'I';
IGRAPH_CHECK(igraph_vector_resize(myvalues, iu-il+1));
IGRAPH_CHECK(igraph_vector_int_resize(mysupport, 2*(iu-il+1)));
if (vectors) { IGRAPH_CHECK(igraph_matrix_resize(vectors, n, iu-il+1)); }
break;
}
igraphdsyevr_(&jobz, &range, &uplo, &n, &MATRIX(Acopy,0,0), &lda,
&vl, &vu, &il, &iu, &abstol, &m, VECTOR(*myvalues),
vectors ? &MATRIX(*vectors,0,0) : 0, &ldz, VECTOR(*mysupport),
VECTOR(work), &lwork, VECTOR(iwork), &liwork, &info);
lwork=(int) VECTOR(work)[0];
liwork=VECTOR(iwork)[0];
IGRAPH_CHECK(igraph_vector_resize(&work, lwork));
IGRAPH_CHECK(igraph_vector_int_resize(&iwork, liwork));
igraphdsyevr_(&jobz, &range, &uplo, &n, &MATRIX(Acopy,0,0), &lda,
&vl, &vu, &il, &iu, &abstol, &m, VECTOR(*myvalues),
vectors ? &MATRIX(*vectors,0,0) : 0, &ldz, VECTOR(*mysupport),
VECTOR(work), &lwork, VECTOR(iwork), &liwork, &info);
if (values) {
IGRAPH_CHECK(igraph_vector_resize(values, m));
}
if (vectors) {
IGRAPH_CHECK(igraph_matrix_resize(vectors, n, m));
}
if (support) {
IGRAPH_CHECK(igraph_vector_int_resize(support, m));
}
if (!support) {
igraph_vector_int_destroy(&vsupport);
IGRAPH_FINALLY_CLEAN(1);
}
if (!values) {
igraph_vector_destroy(&vvalues);
IGRAPH_FINALLY_CLEAN(1);
}
igraph_vector_int_destroy(&iwork);
igraph_vector_destroy(&work);
igraph_matrix_destroy(&Acopy);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
Matrix &Matrix::operator=(const Matrix &matrix) & {
this->~Matrix();
SafeCall(igraph_matrix_copy(ptr(), matrix.ptr()));
return *this;
}
Matrix::Matrix(const Matrix &matrix) {
SafeCall(igraph_matrix_copy(ptr(), matrix.ptr()));
}
