[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Res: [Help-gsl] Next release?
From: |
Paulo Jabardo |
Subject: |
Res: [Help-gsl] Next release? |
Date: |
Thu, 7 Dec 2006 14:10:44 -0800 (PST) |
I have no idea of that but I recommend using lapack (while the new version for
gsl is not out). I think you are looking for function dgeev
(www.netlib.org/lapack):
SUBROUTINE DGEEV( JOBVL, JOBVR, N, A, LDA, WR, WI, VL, LDVL, VR,
$ LDVR, WORK, LWORK, INFO )
CHARACTER JOBVL, JOBVR
INTEGER INFO, LDA, LDVL, LDVR, LWORK, N
* ..
* .. Array Arguments ..
DOUBLE PRECISION A( LDA, * ), VL( LDVL, * ), VR( LDVR, * ),
$ WI( * ), WORK( * ), WR( * )
To use this function in C with gsl matrices, you should declare the function as
follows (at least in linux)
void
dgeev_(char* jobvl, char *jobvr, int *n, double *A, int *lda, double *wr,
double *wi, double *vl,
int *ldvl, double *vr, int *ldvr, double *work, int *lwork, int *info)
to call it with gsl matrices and vectors use something like:
gsl_matrix *a, *vl, *vr;
gsl_vector *wi, *work, *wr;
...
dgeev_("V", "N", &a->size1, a->data, &a->tda, wr->data, wi->data, vl->data,
&ldvl->tda, vr->data, &vr->tda, work->data, &work->size, &info);
In order to link, you will probably need to link the fortran libraries, in case
of g77 it is g2c.
If you are using C++, don't forget to declare the function inside a extern "C"{
declaration }
Below is the documentation of the function taken from file dgeev.f found in the
lapack distribution.
Paulo
* Purpose
* =======
*
* DGEEV computes for an N-by-N real nonsymmetric matrix A, the
* eigenvalues and, optionally, the left and/or right eigenvectors.
*
* The right eigenvector v(j) of A satisfies
* A * v(j) = lambda(j) * v(j)
* where lambda(j) is its eigenvalue.
* The left eigenvector u(j) of A satisfies
* u(j)**H * A = lambda(j) * u(j)**H
* where u(j)**H denotes the conjugate transpose of u(j).
*
* The computed eigenvectors are normalized to have Euclidean norm
* equal to 1 and largest component real.
*
* Arguments
* =========
*
* JOBVL (input) CHARACTER*1
* = 'N': left eigenvectors of A are not computed;
* = 'V': left eigenvectors of A are computed.
*
* JOBVR (input) CHARACTER*1
* = 'N': right eigenvectors of A are not computed;
* = 'V': right eigenvectors of A are computed.
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the N-by-N matrix A.
* On exit, A has been overwritten.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
* WR (output) DOUBLE PRECISION array, dimension (N)
* WI (output) DOUBLE PRECISION array, dimension (N)
* WR and WI contain the real and imaginary parts,
* respectively, of the computed eigenvalues. Complex
* conjugate pairs of eigenvalues appear consecutively
* with the eigenvalue having the positive imaginary part
* first.
*
* VL (output) DOUBLE PRECISION array, dimension (LDVL,N)
* If JOBVL = 'V', the left eigenvectors u(j) are stored one
* after another in the columns of VL, in the same order
* as their eigenvalues.
* If JOBVL = 'N', VL is not referenced.
* If the j-th eigenvalue is real, then u(j) = VL(:,j),
* the j-th column of VL.
* If the j-th and (j+1)-st eigenvalues form a complex
* conjugate pair, then u(j) = VL(:,j) + i*VL(:,j+1) and
* u(j+1) = VL(:,j) - i*VL(:,j+1).
*
* LDVL (input) INTEGER
* The leading dimension of the array VL. LDVL >= 1; if
* JOBVL = 'V', LDVL >= N.
*
* VR (output) DOUBLE PRECISION array, dimension (LDVR,N)
* If JOBVR = 'V', the right eigenvectors v(j) are stored one
* after another in the columns of VR, in the same order
* as their eigenvalues.
* If JOBVR = 'N', VR is not referenced.
* If the j-th eigenvalue is real, then v(j) = VR(:,j),
* the j-th column of VR.
* If the j-th and (j+1)-st eigenvalues form a complex
* conjugate pair, then v(j) = VR(:,j) + i*VR(:,j+1) and
* v(j+1) = VR(:,j) - i*VR(:,j+1).
*
* LDVR (input) INTEGER
* The leading dimension of the array VR. LDVR >= 1; if
* JOBVR = 'V', LDVR >= N.
*
* WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK)
* On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
*
* LWORK (input) INTEGER
* The dimension of the array WORK. LWORK >= max(1,3*N), and
* if JOBVL = 'V' or JOBVR = 'V', LWORK >= 4*N. For good
* performance, LWORK must generally be larger.
*
* If LWORK = -1, then a workspace query is assumed; the routine
* only calculates the optimal size of the WORK array, returns
* this value as the first entry of the WORK array, and no error
* message related to LWORK is issued by XERBLA.
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = -i, the i-th argument had an illegal value.
* > 0: if INFO = i, the QR algorithm failed to compute all the
* eigenvalues, and no eigenvectors have been computed;
* elements i+1:N of WR and WI contain eigenvalues which
* have converged.
*
* =====================================================================
*
----- Mensagem original ----
De: Brian O'Meara <address@hidden>
Para: address@hidden
Cc: Brian O'Meara <address@hidden>
Enviadas: Quinta-feira, 7 de Dezembro de 2006 17:37:30
Assunto: [Help-gsl] Next release?
I need to get the eigenvalues and eigenvectors for a nonsymmetric
matrix. I know this will be in the next version of the gsl. Is there
a rough estimate of when this will be released? I'm trying to decide
whether to do a quick cobbled solution for a particular question or
to do a more general solution (in either case, I'd switch over to gsl
routines when they come out).
And thanks to the developers for your continued work on the GSL.
Brian O'Meara
_______________________________________________
Help-gsl mailing list
address@hidden
http://lists.gnu.org/mailman/listinfo/help-gsl
_______________________________________________________
O Yahoo! estÃ¡ de cara nova. Venha conferir!
http://br.yahoo.com
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- Res: [Help-gsl] Next release?,
Paulo Jabardo <=