ruby-lapack 1.7.1 → 1.7.2
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/Rakefile +1 -1
- data/dev/defs/claed7 +1 -1
- data/dev/defs/clarrv +1 -1
- data/dev/defs/dlaed1 +1 -1
- data/dev/defs/dlaed7 +1 -1
- data/dev/defs/dlag2 +16 -16
- data/dev/defs/dlag2s +13 -13
- data/dev/defs/dlarrf +1 -1
- data/dev/defs/dlarrv +1 -1
- data/dev/defs/dlasd1 +1 -1
- data/dev/defs/dlasd6 +1 -1
- data/dev/defs/slaed1 +1 -1
- data/dev/defs/slaed7 +1 -1
- data/dev/defs/slag2 +16 -16
- data/dev/defs/slarrf +1 -1
- data/dev/defs/slarrv +1 -1
- data/dev/defs/slasd1 +1 -1
- data/dev/defs/slasd6 +1 -1
- data/dev/defs/zlaed7 +1 -1
- data/dev/defs/zlag2c +13 -13
- data/dev/defs/zlarrv +1 -1
- data/dev/make_csrc.rb +8 -8
- data/dev/parse.rb +40 -44
- data/ext/claed7.c +1 -1
- data/ext/clarrv.c +1 -1
- data/ext/dlaed1.c +1 -1
- data/ext/dlaed7.c +1 -1
- data/ext/dlag2.c +1 -1
- data/ext/dlag2s.c +1 -1
- data/ext/dlarrf.c +1 -1
- data/ext/dlarrv.c +1 -1
- data/ext/dlasd1.c +1 -1
- data/ext/dlasd6.c +1 -1
- data/ext/extconf.rb +26 -12
- data/ext/f2c_minimal.h +4 -2
- data/ext/slaed1.c +1 -1
- data/ext/slaed7.c +1 -1
- data/ext/slag2.c +1 -1
- data/ext/slarrf.c +1 -1
- data/ext/slarrv.c +1 -1
- data/ext/slasd1.c +1 -1
- data/ext/slasd6.c +1 -1
- data/ext/zlaed7.c +1 -1
- data/ext/zlag2c.c +1 -1
- data/ext/zlarrv.c +1 -1
- metadata +3 -3
data/ext/f2c_minimal.h
CHANGED
|
@@ -7,7 +7,9 @@
|
|
|
7
7
|
#ifndef F2C_INCLUDE
|
|
8
8
|
#define F2C_INCLUDE
|
|
9
9
|
|
|
10
|
-
#
|
|
10
|
+
#include <stdint.h>
|
|
11
|
+
|
|
12
|
+
#if UINTPTR_MAX == UINT64_MAX
|
|
11
13
|
typedef int integer;
|
|
12
14
|
typedef int logical;
|
|
13
15
|
#else
|
|
@@ -22,7 +24,7 @@ typedef struct { doublereal r, i; } doublecomplex;
|
|
|
22
24
|
#ifdef f2c_i2
|
|
23
25
|
typedef short ftnlen;
|
|
24
26
|
#else
|
|
25
|
-
#if
|
|
27
|
+
#if UINTPTR_MAX == UINT64_MAX
|
|
26
28
|
typedef int ftnlen;
|
|
27
29
|
#else
|
|
28
30
|
typedef long int ftnlen;
|
data/ext/slaed1.c
CHANGED
|
@@ -34,7 +34,7 @@ rblapack_slaed1(int argc, VALUE *argv, VALUE self){
|
|
|
34
34
|
argc--;
|
|
35
35
|
rblapack_options = argv[argc];
|
|
36
36
|
if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
|
|
37
|
-
printf("%s\n", "USAGE:\n info, d, q, indxq = NumRu::Lapack.slaed1( d, q, indxq, rho, cutpnt, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLAED1( N, D, Q, LDQ, INDXQ, RHO, CUTPNT, WORK, IWORK, INFO )\n\n* Purpose\n* =======\n*\n* SLAED1 computes the updated eigensystem of a diagonal\n* matrix after modification by a rank-one symmetric matrix. This\n* routine is used only for the eigenproblem which requires all\n* eigenvalues and eigenvectors of a tridiagonal matrix. SLAED7 handles\n* the case in which eigenvalues only or eigenvalues and eigenvectors\n* of a full symmetric matrix (which was reduced to tridiagonal form)\n* are desired.\n*\n* T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out)\n*\n* where Z = Q'u, u is a vector of length N with ones in the\n* CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.\n*\n* The eigenvectors of the original matrix are stored in Q, and the\n* eigenvalues are in D. The algorithm consists of three stages:\n*\n* The first stage consists of deflating the size of the problem\n* when there are multiple eigenvalues or if there is a zero in\n* the Z vector. For each such
|
|
37
|
+
printf("%s\n", "USAGE:\n info, d, q, indxq = NumRu::Lapack.slaed1( d, q, indxq, rho, cutpnt, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLAED1( N, D, Q, LDQ, INDXQ, RHO, CUTPNT, WORK, IWORK, INFO )\n\n* Purpose\n* =======\n*\n* SLAED1 computes the updated eigensystem of a diagonal\n* matrix after modification by a rank-one symmetric matrix. This\n* routine is used only for the eigenproblem which requires all\n* eigenvalues and eigenvectors of a tridiagonal matrix. SLAED7 handles\n* the case in which eigenvalues only or eigenvalues and eigenvectors\n* of a full symmetric matrix (which was reduced to tridiagonal form)\n* are desired.\n*\n* T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out)\n*\n* where Z = Q'u, u is a vector of length N with ones in the\n* CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.\n*\n* The eigenvectors of the original matrix are stored in Q, and the\n* eigenvalues are in D. The algorithm consists of three stages:\n*\n* The first stage consists of deflating the size of the problem\n* when there are multiple eigenvalues or if there is a zero in\n* the Z vector. For each such occurrence the dimension of the\n* secular equation problem is reduced by one. This stage is\n* performed by the routine SLAED2.\n*\n* The second stage consists of calculating the updated\n* eigenvalues. This is done by finding the roots of the secular\n* equation via the routine SLAED4 (as called by SLAED3).\n* This routine also calculates the eigenvectors of the current\n* problem.\n*\n* The final stage consists of computing the updated eigenvectors\n* directly using the updated eigenvalues. The eigenvectors for\n* the current problem are multiplied with the eigenvectors from\n* the overall problem.\n*\n\n* Arguments\n* =========\n*\n* N (input) INTEGER\n* The dimension of the symmetric tridiagonal matrix. N >= 0.\n*\n* D (input/output) REAL array, dimension (N)\n* On entry, the eigenvalues of the rank-1-perturbed matrix.\n* On exit, the eigenvalues of the repaired matrix.\n*\n* Q (input/output) REAL array, dimension (LDQ,N)\n* On entry, the eigenvectors of the rank-1-perturbed matrix.\n* On exit, the eigenvectors of the repaired tridiagonal matrix.\n*\n* LDQ (input) INTEGER\n* The leading dimension of the array Q. LDQ >= max(1,N).\n*\n* INDXQ (input/output) INTEGER array, dimension (N)\n* On entry, the permutation which separately sorts the two\n* subproblems in D into ascending order.\n* On exit, the permutation which will reintegrate the\n* subproblems back into sorted order,\n* i.e. D( INDXQ( I = 1, N ) ) will be in ascending order.\n*\n* RHO (input) REAL\n* The subdiagonal entry used to create the rank-1 modification.\n*\n* CUTPNT (input) INTEGER\n* The location of the last eigenvalue in the leading sub-matrix.\n* min(1,N) <= CUTPNT <= N/2.\n*\n* WORK (workspace) REAL array, dimension (4*N + N**2)\n*\n* IWORK (workspace) INTEGER array, dimension (4*N)\n*\n* INFO (output) INTEGER\n* = 0: successful exit.\n* < 0: if INFO = -i, the i-th argument had an illegal value.\n* > 0: if INFO = 1, an eigenvalue did not converge\n*\n\n* Further Details\n* ===============\n*\n* Based on contributions by\n* Jeff Rutter, Computer Science Division, University of California\n* at Berkeley, USA\n* Modified by Francoise Tisseur, University of Tennessee.\n*\n* =====================================================================\n*\n* .. Local Scalars ..\n INTEGER COLTYP, CPP1, I, IDLMDA, INDX, INDXC, INDXP,\n $ IQ2, IS, IW, IZ, K, N1, N2\n* ..\n* .. External Subroutines ..\n EXTERNAL SCOPY, SLAED2, SLAED3, SLAMRG, XERBLA\n* ..\n* .. Intrinsic Functions ..\n INTRINSIC MAX, MIN\n* ..\n\n");
|
|
38
38
|
return Qnil;
|
|
39
39
|
}
|
|
40
40
|
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
|
data/ext/slaed7.c
CHANGED
|
@@ -60,7 +60,7 @@ rblapack_slaed7(int argc, VALUE *argv, VALUE self){
|
|
|
60
60
|
argc--;
|
|
61
61
|
rblapack_options = argv[argc];
|
|
62
62
|
if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
|
|
63
|
-
printf("%s\n", "USAGE:\n indxq, info, d, q, qstore, qptr = NumRu::Lapack.slaed7( icompq, qsiz, tlvls, curlvl, curpbm, d, q, rho, cutpnt, qstore, qptr, prmptr, perm, givptr, givcol, givnum, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLAED7( ICOMPQ, N, QSIZ, TLVLS, CURLVL, CURPBM, D, Q, LDQ, INDXQ, RHO, CUTPNT, QSTORE, QPTR, PRMPTR, PERM, GIVPTR, GIVCOL, GIVNUM, WORK, IWORK, INFO )\n\n* Purpose\n* =======\n*\n* SLAED7 computes the updated eigensystem of a diagonal\n* matrix after modification by a rank-one symmetric matrix. This\n* routine is used only for the eigenproblem which requires all\n* eigenvalues and optionally eigenvectors of a dense symmetric matrix\n* that has been reduced to tridiagonal form. SLAED1 handles\n* the case in which all eigenvalues and eigenvectors of a symmetric\n* tridiagonal matrix are desired.\n*\n* T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out)\n*\n* where Z = Q'u, u is a vector of length N with ones in the\n* CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.\n*\n* The eigenvectors of the original matrix are stored in Q, and the\n* eigenvalues are in D. The algorithm consists of three stages:\n*\n* The first stage consists of deflating the size of the problem\n* when there are multiple eigenvalues or if there is a zero in\n* the Z vector. For each such
|
|
63
|
+
printf("%s\n", "USAGE:\n indxq, info, d, q, qstore, qptr = NumRu::Lapack.slaed7( icompq, qsiz, tlvls, curlvl, curpbm, d, q, rho, cutpnt, qstore, qptr, prmptr, perm, givptr, givcol, givnum, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLAED7( ICOMPQ, N, QSIZ, TLVLS, CURLVL, CURPBM, D, Q, LDQ, INDXQ, RHO, CUTPNT, QSTORE, QPTR, PRMPTR, PERM, GIVPTR, GIVCOL, GIVNUM, WORK, IWORK, INFO )\n\n* Purpose\n* =======\n*\n* SLAED7 computes the updated eigensystem of a diagonal\n* matrix after modification by a rank-one symmetric matrix. This\n* routine is used only for the eigenproblem which requires all\n* eigenvalues and optionally eigenvectors of a dense symmetric matrix\n* that has been reduced to tridiagonal form. SLAED1 handles\n* the case in which all eigenvalues and eigenvectors of a symmetric\n* tridiagonal matrix are desired.\n*\n* T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out)\n*\n* where Z = Q'u, u is a vector of length N with ones in the\n* CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.\n*\n* The eigenvectors of the original matrix are stored in Q, and the\n* eigenvalues are in D. The algorithm consists of three stages:\n*\n* The first stage consists of deflating the size of the problem\n* when there are multiple eigenvalues or if there is a zero in\n* the Z vector. For each such occurrence the dimension of the\n* secular equation problem is reduced by one. This stage is\n* performed by the routine SLAED8.\n*\n* The second stage consists of calculating the updated\n* eigenvalues. This is done by finding the roots of the secular\n* equation via the routine SLAED4 (as called by SLAED9).\n* This routine also calculates the eigenvectors of the current\n* problem.\n*\n* The final stage consists of computing the updated eigenvectors\n* directly using the updated eigenvalues. The eigenvectors for\n* the current problem are multiplied with the eigenvectors from\n* the overall problem.\n*\n\n* Arguments\n* =========\n*\n* ICOMPQ (input) INTEGER\n* = 0: Compute eigenvalues only.\n* = 1: Compute eigenvectors of original dense symmetric matrix\n* also. On entry, Q contains the orthogonal matrix used\n* to reduce the original matrix to tridiagonal form.\n*\n* N (input) INTEGER\n* The dimension of the symmetric tridiagonal matrix. N >= 0.\n*\n* QSIZ (input) INTEGER\n* The dimension of the orthogonal matrix used to reduce\n* the full matrix to tridiagonal form. QSIZ >= N if ICOMPQ = 1.\n*\n* TLVLS (input) INTEGER\n* The total number of merging levels in the overall divide and\n* conquer tree.\n*\n* CURLVL (input) INTEGER\n* The current level in the overall merge routine,\n* 0 <= CURLVL <= TLVLS.\n*\n* CURPBM (input) INTEGER\n* The current problem in the current level in the overall\n* merge routine (counting from upper left to lower right).\n*\n* D (input/output) REAL array, dimension (N)\n* On entry, the eigenvalues of the rank-1-perturbed matrix.\n* On exit, the eigenvalues of the repaired matrix.\n*\n* Q (input/output) REAL array, dimension (LDQ, N)\n* On entry, the eigenvectors of the rank-1-perturbed matrix.\n* On exit, the eigenvectors of the repaired tridiagonal matrix.\n*\n* LDQ (input) INTEGER\n* The leading dimension of the array Q. LDQ >= max(1,N).\n*\n* INDXQ (output) INTEGER array, dimension (N)\n* The permutation which will reintegrate the subproblem just\n* solved back into sorted order, i.e., D( INDXQ( I = 1, N ) )\n* will be in ascending order.\n*\n* RHO (input) REAL\n* The subdiagonal element used to create the rank-1\n* modification.\n*\n* CUTPNT (input) INTEGER\n* Contains the location of the last eigenvalue in the leading\n* sub-matrix. min(1,N) <= CUTPNT <= N.\n*\n* QSTORE (input/output) REAL array, dimension (N**2+1)\n* Stores eigenvectors of submatrices encountered during\n* divide and conquer, packed together. QPTR points to\n* beginning of the submatrices.\n*\n* QPTR (input/output) INTEGER array, dimension (N+2)\n* List of indices pointing to beginning of submatrices stored\n* in QSTORE. The submatrices are numbered starting at the\n* bottom left of the divide and conquer tree, from left to\n* right and bottom to top.\n*\n* PRMPTR (input) INTEGER array, dimension (N lg N)\n* Contains a list of pointers which indicate where in PERM a\n* level's permutation is stored. PRMPTR(i+1) - PRMPTR(i)\n* indicates the size of the permutation and also the size of\n* the full, non-deflated problem.\n*\n* PERM (input) INTEGER array, dimension (N lg N)\n* Contains the permutations (from deflation and sorting) to be\n* applied to each eigenblock.\n*\n* GIVPTR (input) INTEGER array, dimension (N lg N)\n* Contains a list of pointers which indicate where in GIVCOL a\n* level's Givens rotations are stored. GIVPTR(i+1) - GIVPTR(i)\n* indicates the number of Givens rotations.\n*\n* GIVCOL (input) INTEGER array, dimension (2, N lg N)\n* Each pair of numbers indicates a pair of columns to take place\n* in a Givens rotation.\n*\n* GIVNUM (input) REAL array, dimension (2, N lg N)\n* Each number indicates the S value to be used in the\n* corresponding Givens rotation.\n*\n* WORK (workspace) REAL array, dimension (3*N+QSIZ*N)\n*\n* IWORK (workspace) INTEGER array, dimension (4*N)\n*\n* INFO (output) INTEGER\n* = 0: successful exit.\n* < 0: if INFO = -i, the i-th argument had an illegal value.\n* > 0: if INFO = 1, an eigenvalue did not converge\n*\n\n* Further Details\n* ===============\n*\n* Based on contributions by\n* Jeff Rutter, Computer Science Division, University of California\n* at Berkeley, USA\n*\n* =====================================================================\n*\n\n");
|
|
64
64
|
return Qnil;
|
|
65
65
|
}
|
|
66
66
|
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
|
data/ext/slag2.c
CHANGED
|
@@ -30,7 +30,7 @@ rblapack_slag2(int argc, VALUE *argv, VALUE self){
|
|
|
30
30
|
argc--;
|
|
31
31
|
rblapack_options = argv[argc];
|
|
32
32
|
if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
|
|
33
|
-
printf("%s\n", "USAGE:\n scale1, scale2, wr1, wr2, wi = NumRu::Lapack.slag2( a, b, safmin, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLAG2( A, LDA, B, LDB, SAFMIN, SCALE1, SCALE2, WR1, WR2, WI )\n\n* Purpose\n* =======\n*\n* SLAG2 computes the eigenvalues of a 2 x 2 generalized eigenvalue\n* problem A - w B, with scaling as necessary to avoid over-/underflow.\n*\n* The scaling factor \"s\" results in a modified eigenvalue equation\n*\n* s A - w B\n*\n* where s is a non-negative scaling factor chosen so that w, w B,\n* and s A do not overflow and, if possible, do not underflow, either.\n*\n\n* Arguments\n* =========\n*\n* A (input) REAL array, dimension (LDA, 2)\n* On entry, the 2 x 2 matrix A. It is assumed that its 1-norm\n* is less than 1/SAFMIN. Entries less than\n* sqrt(SAFMIN)*norm(A) are subject to being treated as zero.\n*\n* LDA (input) INTEGER\n* The leading dimension of the array A. LDA >= 2.\n*\n* B (input) REAL array, dimension (LDB, 2)\n* On entry, the 2 x 2 upper triangular matrix B. It is\n* assumed that the one-norm of B is less than 1/SAFMIN. The\n* diagonals should be at least sqrt(SAFMIN) times the largest\n* element of B (in absolute value); if a diagonal is smaller\n* than that, then +/- sqrt(SAFMIN) will be used instead of\n* that diagonal.\n*\n* LDB (input) INTEGER\n* The leading dimension of the array B. LDB >= 2.\n*\n* SAFMIN (input) REAL\n* The smallest positive number s.t. 1/SAFMIN does not\n* overflow. (This should always be SLAMCH('S') -- it is an\n* argument in order to avoid having to call SLAMCH frequently.)\n*\n* SCALE1 (output) REAL\n* A scaling factor used to avoid over-/underflow in the\n* eigenvalue equation which defines the first eigenvalue. If\n* the eigenvalues are complex, then the eigenvalues are\n* ( WR1 +/- WI i ) / SCALE1 (which may lie outside the\n* exponent range of the machine), SCALE1=SCALE2, and SCALE1\n* will always be positive. If the eigenvalues are real, then\n* the first (real) eigenvalue is WR1 / SCALE1 , but this may\n* overflow or underflow, and in fact, SCALE1 may be zero or\n* less than the underflow
|
|
33
|
+
printf("%s\n", "USAGE:\n scale1, scale2, wr1, wr2, wi = NumRu::Lapack.slag2( a, b, safmin, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLAG2( A, LDA, B, LDB, SAFMIN, SCALE1, SCALE2, WR1, WR2, WI )\n\n* Purpose\n* =======\n*\n* SLAG2 computes the eigenvalues of a 2 x 2 generalized eigenvalue\n* problem A - w B, with scaling as necessary to avoid over-/underflow.\n*\n* The scaling factor \"s\" results in a modified eigenvalue equation\n*\n* s A - w B\n*\n* where s is a non-negative scaling factor chosen so that w, w B,\n* and s A do not overflow and, if possible, do not underflow, either.\n*\n\n* Arguments\n* =========\n*\n* A (input) REAL array, dimension (LDA, 2)\n* On entry, the 2 x 2 matrix A. It is assumed that its 1-norm\n* is less than 1/SAFMIN. Entries less than\n* sqrt(SAFMIN)*norm(A) are subject to being treated as zero.\n*\n* LDA (input) INTEGER\n* The leading dimension of the array A. LDA >= 2.\n*\n* B (input) REAL array, dimension (LDB, 2)\n* On entry, the 2 x 2 upper triangular matrix B. It is\n* assumed that the one-norm of B is less than 1/SAFMIN. The\n* diagonals should be at least sqrt(SAFMIN) times the largest\n* element of B (in absolute value); if a diagonal is smaller\n* than that, then +/- sqrt(SAFMIN) will be used instead of\n* that diagonal.\n*\n* LDB (input) INTEGER\n* The leading dimension of the array B. LDB >= 2.\n*\n* SAFMIN (input) REAL\n* The smallest positive number s.t. 1/SAFMIN does not\n* overflow. (This should always be SLAMCH('S') -- it is an\n* argument in order to avoid having to call SLAMCH frequently.)\n*\n* SCALE1 (output) REAL\n* A scaling factor used to avoid over-/underflow in the\n* eigenvalue equation which defines the first eigenvalue. If\n* the eigenvalues are complex, then the eigenvalues are\n* ( WR1 +/- WI i ) / SCALE1 (which may lie outside the\n* exponent range of the machine), SCALE1=SCALE2, and SCALE1\n* will always be positive. If the eigenvalues are real, then\n* the first (real) eigenvalue is WR1 / SCALE1 , but this may\n* overflow or underflow, and in fact, SCALE1 may be zero or\n* less than the underflow threshold if the exact eigenvalue\n* is sufficiently large.\n*\n* SCALE2 (output) REAL\n* A scaling factor used to avoid over-/underflow in the\n* eigenvalue equation which defines the second eigenvalue. If\n* the eigenvalues are complex, then SCALE2=SCALE1. If the\n* eigenvalues are real, then the second (real) eigenvalue is\n* WR2 / SCALE2 , but this may overflow or underflow, and in\n* fact, SCALE2 may be zero or less than the underflow\n* threshold if the exact eigenvalue is sufficiently large.\n*\n* WR1 (output) REAL\n* If the eigenvalue is real, then WR1 is SCALE1 times the\n* eigenvalue closest to the (2,2) element of A B**(-1). If the\n* eigenvalue is complex, then WR1=WR2 is SCALE1 times the real\n* part of the eigenvalues.\n*\n* WR2 (output) REAL\n* If the eigenvalue is real, then WR2 is SCALE2 times the\n* other eigenvalue. If the eigenvalue is complex, then\n* WR1=WR2 is SCALE1 times the real part of the eigenvalues.\n*\n* WI (output) REAL\n* If the eigenvalue is real, then WI is zero. If the\n* eigenvalue is complex, then WI is SCALE1 times the imaginary\n* part of the eigenvalues. WI will always be non-negative.\n*\n\n* =====================================================================\n*\n\n");
|
|
34
34
|
return Qnil;
|
|
35
35
|
}
|
|
36
36
|
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
|
data/ext/slarrf.c
CHANGED
|
@@ -48,7 +48,7 @@ rblapack_slarrf(int argc, VALUE *argv, VALUE self){
|
|
|
48
48
|
argc--;
|
|
49
49
|
rblapack_options = argv[argc];
|
|
50
50
|
if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
|
|
51
|
-
printf("%s\n", "USAGE:\n sigma, dplus, lplus, info, wgap = NumRu::Lapack.slarrf( d, l, ld, clstrt, clend, w, wgap, werr, spdiam, clgapl, clgapr, pivmin, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLARRF( N, D, L, LD, CLSTRT, CLEND, W, WGAP, WERR, SPDIAM, CLGAPL, CLGAPR, PIVMIN, SIGMA, DPLUS, LPLUS, WORK, INFO )\n\n* Purpose\n* =======\n*\n* Given the initial representation L D L^T and its cluster of close\n* eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ...\n* W( CLEND ), SLARRF finds a new relatively robust representation\n* L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the\n* eigenvalues of L(+) D(+) L(+)^T is relatively isolated.\n*\n\n* Arguments\n* =========\n*\n* N (input) INTEGER\n* The order of the matrix (subblock, if the matrix
|
|
51
|
+
printf("%s\n", "USAGE:\n sigma, dplus, lplus, info, wgap = NumRu::Lapack.slarrf( d, l, ld, clstrt, clend, w, wgap, werr, spdiam, clgapl, clgapr, pivmin, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLARRF( N, D, L, LD, CLSTRT, CLEND, W, WGAP, WERR, SPDIAM, CLGAPL, CLGAPR, PIVMIN, SIGMA, DPLUS, LPLUS, WORK, INFO )\n\n* Purpose\n* =======\n*\n* Given the initial representation L D L^T and its cluster of close\n* eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ...\n* W( CLEND ), SLARRF finds a new relatively robust representation\n* L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the\n* eigenvalues of L(+) D(+) L(+)^T is relatively isolated.\n*\n\n* Arguments\n* =========\n*\n* N (input) INTEGER\n* The order of the matrix (subblock, if the matrix split).\n*\n* D (input) REAL array, dimension (N)\n* The N diagonal elements of the diagonal matrix D.\n*\n* L (input) REAL array, dimension (N-1)\n* The (N-1) subdiagonal elements of the unit bidiagonal\n* matrix L.\n*\n* LD (input) REAL array, dimension (N-1)\n* The (N-1) elements L(i)*D(i).\n*\n* CLSTRT (input) INTEGER\n* The index of the first eigenvalue in the cluster.\n*\n* CLEND (input) INTEGER\n* The index of the last eigenvalue in the cluster.\n*\n* W (input) REAL array, dimension\n* dimension is >= (CLEND-CLSTRT+1)\n* The eigenvalue APPROXIMATIONS of L D L^T in ascending order.\n* W( CLSTRT ) through W( CLEND ) form the cluster of relatively\n* close eigenalues.\n*\n* WGAP (input/output) REAL array, dimension\n* dimension is >= (CLEND-CLSTRT+1)\n* The separation from the right neighbor eigenvalue in W.\n*\n* WERR (input) REAL array, dimension\n* dimension is >= (CLEND-CLSTRT+1)\n* WERR contain the semiwidth of the uncertainty\n* interval of the corresponding eigenvalue APPROXIMATION in W\n*\n* SPDIAM (input) REAL\n* estimate of the spectral diameter obtained from the\n* Gerschgorin intervals\n*\n* CLGAPL (input) REAL\n*\n* CLGAPR (input) REAL\n* absolute gap on each end of the cluster.\n* Set by the calling routine to protect against shifts too close\n* to eigenvalues outside the cluster.\n*\n* PIVMIN (input) REAL\n* The minimum pivot allowed in the Sturm sequence.\n*\n* SIGMA (output) REAL \n* The shift used to form L(+) D(+) L(+)^T.\n*\n* DPLUS (output) REAL array, dimension (N)\n* The N diagonal elements of the diagonal matrix D(+).\n*\n* LPLUS (output) REAL array, dimension (N-1)\n* The first (N-1) elements of LPLUS contain the subdiagonal\n* elements of the unit bidiagonal matrix L(+).\n*\n* WORK (workspace) REAL array, dimension (2*N)\n* Workspace.\n*\n\n* Further Details\n* ===============\n*\n* Based on contributions by\n* Beresford Parlett, University of California, Berkeley, USA\n* Jim Demmel, University of California, Berkeley, USA\n* Inderjit Dhillon, University of Texas, Austin, USA\n* Osni Marques, LBNL/NERSC, USA\n* Christof Voemel, University of California, Berkeley, USA\n*\n* =====================================================================\n*\n\n");
|
|
52
52
|
return Qnil;
|
|
53
53
|
}
|
|
54
54
|
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
|
data/ext/slarrv.c
CHANGED
|
@@ -68,7 +68,7 @@ rblapack_slarrv(int argc, VALUE *argv, VALUE self){
|
|
|
68
68
|
argc--;
|
|
69
69
|
rblapack_options = argv[argc];
|
|
70
70
|
if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
|
|
71
|
-
printf("%s\n", "USAGE:\n z, isuppz, info, d, l, w, werr, wgap = NumRu::Lapack.slarrv( vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLARRV( N, VL, VU, D, L, PIVMIN, ISPLIT, M, DOL, DOU, MINRGP, RTOL1, RTOL2, W, WERR, WGAP, IBLOCK, INDEXW, GERS, Z, LDZ, ISUPPZ, WORK, IWORK, INFO )\n\n* Purpose\n* =======\n*\n* SLARRV computes the eigenvectors of the tridiagonal matrix\n* T = L D L^T given L, D and APPROXIMATIONS to the eigenvalues of L D L^T.\n* The input eigenvalues should have been computed by SLARRE.\n*\n\n* Arguments\n* =========\n*\n* N (input) INTEGER\n* The order of the matrix. N >= 0.\n*\n* VL (input) REAL \n* VU (input) REAL \n* Lower and upper bounds of the interval that contains the desired\n* eigenvalues. VL < VU. Needed to compute gaps on the left or right\n* end of the extremal eigenvalues in the desired RANGE.\n*\n* D (input/output) REAL array, dimension (N)\n* On entry, the N diagonal elements of the diagonal matrix D.\n* On exit, D may be overwritten.\n*\n* L (input/output) REAL array, dimension (N)\n* On entry, the (N-1) subdiagonal elements of the unit\n* bidiagonal matrix L are in elements 1 to N-1 of L\n* (if the matrix is not
|
|
71
|
+
printf("%s\n", "USAGE:\n z, isuppz, info, d, l, w, werr, wgap = NumRu::Lapack.slarrv( vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLARRV( N, VL, VU, D, L, PIVMIN, ISPLIT, M, DOL, DOU, MINRGP, RTOL1, RTOL2, W, WERR, WGAP, IBLOCK, INDEXW, GERS, Z, LDZ, ISUPPZ, WORK, IWORK, INFO )\n\n* Purpose\n* =======\n*\n* SLARRV computes the eigenvectors of the tridiagonal matrix\n* T = L D L^T given L, D and APPROXIMATIONS to the eigenvalues of L D L^T.\n* The input eigenvalues should have been computed by SLARRE.\n*\n\n* Arguments\n* =========\n*\n* N (input) INTEGER\n* The order of the matrix. N >= 0.\n*\n* VL (input) REAL \n* VU (input) REAL \n* Lower and upper bounds of the interval that contains the desired\n* eigenvalues. VL < VU. Needed to compute gaps on the left or right\n* end of the extremal eigenvalues in the desired RANGE.\n*\n* D (input/output) REAL array, dimension (N)\n* On entry, the N diagonal elements of the diagonal matrix D.\n* On exit, D may be overwritten.\n*\n* L (input/output) REAL array, dimension (N)\n* On entry, the (N-1) subdiagonal elements of the unit\n* bidiagonal matrix L are in elements 1 to N-1 of L\n* (if the matrix is not split.) At the end of each block\n* is stored the corresponding shift as given by SLARRE.\n* On exit, L is overwritten.\n*\n* PIVMIN (input) REAL\n* The minimum pivot allowed in the Sturm sequence.\n*\n* ISPLIT (input) INTEGER array, dimension (N)\n* The splitting points, at which T breaks up into blocks.\n* The first block consists of rows/columns 1 to\n* ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1\n* through ISPLIT( 2 ), etc.\n*\n* M (input) INTEGER\n* The total number of input eigenvalues. 0 <= M <= N.\n*\n* DOL (input) INTEGER\n* DOU (input) INTEGER\n* If the user wants to compute only selected eigenvectors from all\n* the eigenvalues supplied, he can specify an index range DOL:DOU.\n* Or else the setting DOL=1, DOU=M should be applied.\n* Note that DOL and DOU refer to the order in which the eigenvalues\n* are stored in W.\n* If the user wants to compute only selected eigenpairs, then\n* the columns DOL-1 to DOU+1 of the eigenvector space Z contain the\n* computed eigenvectors. All other columns of Z are set to zero.\n*\n* MINRGP (input) REAL \n*\n* RTOL1 (input) REAL \n* RTOL2 (input) REAL \n* Parameters for bisection.\n* An interval [LEFT,RIGHT] has converged if\n* RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )\n*\n* W (input/output) REAL array, dimension (N)\n* The first M elements of W contain the APPROXIMATE eigenvalues for\n* which eigenvectors are to be computed. The eigenvalues\n* should be grouped by split-off block and ordered from\n* smallest to largest within the block ( The output array\n* W from SLARRE is expected here ). Furthermore, they are with\n* respect to the shift of the corresponding root representation\n* for their block. On exit, W holds the eigenvalues of the\n* UNshifted matrix.\n*\n* WERR (input/output) REAL array, dimension (N)\n* The first M elements contain the semiwidth of the uncertainty\n* interval of the corresponding eigenvalue in W\n*\n* WGAP (input/output) REAL array, dimension (N)\n* The separation from the right neighbor eigenvalue in W.\n*\n* IBLOCK (input) INTEGER array, dimension (N)\n* The indices of the blocks (submatrices) associated with the\n* corresponding eigenvalues in W; IBLOCK(i)=1 if eigenvalue\n* W(i) belongs to the first block from the top, =2 if W(i)\n* belongs to the second block, etc.\n*\n* INDEXW (input) INTEGER array, dimension (N)\n* The indices of the eigenvalues within each block (submatrix);\n* for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the\n* i-th eigenvalue W(i) is the 10-th eigenvalue in the second block.\n*\n* GERS (input) REAL array, dimension (2*N)\n* The N Gerschgorin intervals (the i-th Gerschgorin interval\n* is (GERS(2*i-1), GERS(2*i)). The Gerschgorin intervals should\n* be computed from the original UNshifted matrix.\n*\n* Z (output) REAL array, dimension (LDZ, max(1,M) )\n* If INFO = 0, the first M columns of Z contain the\n* orthonormal eigenvectors of the matrix T\n* corresponding to the input eigenvalues, with the i-th\n* column of Z holding the eigenvector associated with W(i).\n* Note: the user must ensure that at least max(1,M) columns are\n* supplied in the array Z.\n*\n* LDZ (input) INTEGER\n* The leading dimension of the array Z. LDZ >= 1, and if\n* JOBZ = 'V', LDZ >= max(1,N).\n*\n* ISUPPZ (output) INTEGER array, dimension ( 2*max(1,M) )\n* The support of the eigenvectors in Z, i.e., the indices\n* indicating the nonzero elements in Z. The I-th eigenvector\n* is nonzero only in elements ISUPPZ( 2*I-1 ) through\n* ISUPPZ( 2*I ).\n*\n* WORK (workspace) REAL array, dimension (12*N)\n*\n* IWORK (workspace) INTEGER array, dimension (7*N)\n*\n* INFO (output) INTEGER\n* = 0: successful exit\n*\n* > 0: A problem occured in SLARRV.\n* < 0: One of the called subroutines signaled an internal problem.\n* Needs inspection of the corresponding parameter IINFO\n* for further information.\n*\n* =-1: Problem in SLARRB when refining a child's eigenvalues.\n* =-2: Problem in SLARRF when computing the RRR of a child.\n* When a child is inside a tight cluster, it can be difficult\n* to find an RRR. A partial remedy from the user's point of\n* view is to make the parameter MINRGP smaller and recompile.\n* However, as the orthogonality of the computed vectors is\n* proportional to 1/MINRGP, the user should be aware that\n* he might be trading in precision when he decreases MINRGP.\n* =-3: Problem in SLARRB when refining a single eigenvalue\n* after the Rayleigh correction was rejected.\n* = 5: The Rayleigh Quotient Iteration failed to converge to\n* full accuracy in MAXITR steps.\n*\n\n* Further Details\n* ===============\n*\n* Based on contributions by\n* Beresford Parlett, University of California, Berkeley, USA\n* Jim Demmel, University of California, Berkeley, USA\n* Inderjit Dhillon, University of Texas, Austin, USA\n* Osni Marques, LBNL/NERSC, USA\n* Christof Voemel, University of California, Berkeley, USA\n*\n* =====================================================================\n*\n\n");
|
|
72
72
|
return Qnil;
|
|
73
73
|
}
|
|
74
74
|
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
|
data/ext/slasd1.c
CHANGED
|
@@ -44,7 +44,7 @@ rblapack_slasd1(int argc, VALUE *argv, VALUE self){
|
|
|
44
44
|
argc--;
|
|
45
45
|
rblapack_options = argv[argc];
|
|
46
46
|
if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
|
|
47
|
-
printf("%s\n", "USAGE:\n idxq, info, d, alpha, beta, u, vt = NumRu::Lapack.slasd1( nl, nr, sqre, d, alpha, beta, u, vt, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLASD1( NL, NR, SQRE, D, ALPHA, BETA, U, LDU, VT, LDVT, IDXQ, IWORK, WORK, INFO )\n\n* Purpose\n* =======\n*\n* SLASD1 computes the SVD of an upper bidiagonal N-by-M matrix B,\n* where N = NL + NR + 1 and M = N + SQRE. SLASD1 is called from SLASD0.\n*\n* A related subroutine SLASD7 handles the case in which the singular\n* values (and the singular vectors in factored form) are desired.\n*\n* SLASD1 computes the SVD as follows:\n*\n* ( D1(in) 0 0 0 )\n* B = U(in) * ( Z1' a Z2' b ) * VT(in)\n* ( 0 0 D2(in) 0 )\n*\n* = U(out) * ( D(out) 0) * VT(out)\n*\n* where Z' = (Z1' a Z2' b) = u' VT', and u is a vector of dimension M\n* with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros\n* elsewhere; and the entry b is empty if SQRE = 0.\n*\n* The left singular vectors of the original matrix are stored in U, and\n* the transpose of the right singular vectors are stored in VT, and the\n* singular values are in D. The algorithm consists of three stages:\n*\n* The first stage consists of deflating the size of the problem\n* when there are multiple singular values or when there are zeros in\n* the Z vector. For each such
|
|
47
|
+
printf("%s\n", "USAGE:\n idxq, info, d, alpha, beta, u, vt = NumRu::Lapack.slasd1( nl, nr, sqre, d, alpha, beta, u, vt, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLASD1( NL, NR, SQRE, D, ALPHA, BETA, U, LDU, VT, LDVT, IDXQ, IWORK, WORK, INFO )\n\n* Purpose\n* =======\n*\n* SLASD1 computes the SVD of an upper bidiagonal N-by-M matrix B,\n* where N = NL + NR + 1 and M = N + SQRE. SLASD1 is called from SLASD0.\n*\n* A related subroutine SLASD7 handles the case in which the singular\n* values (and the singular vectors in factored form) are desired.\n*\n* SLASD1 computes the SVD as follows:\n*\n* ( D1(in) 0 0 0 )\n* B = U(in) * ( Z1' a Z2' b ) * VT(in)\n* ( 0 0 D2(in) 0 )\n*\n* = U(out) * ( D(out) 0) * VT(out)\n*\n* where Z' = (Z1' a Z2' b) = u' VT', and u is a vector of dimension M\n* with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros\n* elsewhere; and the entry b is empty if SQRE = 0.\n*\n* The left singular vectors of the original matrix are stored in U, and\n* the transpose of the right singular vectors are stored in VT, and the\n* singular values are in D. The algorithm consists of three stages:\n*\n* The first stage consists of deflating the size of the problem\n* when there are multiple singular values or when there are zeros in\n* the Z vector. For each such occurrence the dimension of the\n* secular equation problem is reduced by one. This stage is\n* performed by the routine SLASD2.\n*\n* The second stage consists of calculating the updated\n* singular values. This is done by finding the square roots of the\n* roots of the secular equation via the routine SLASD4 (as called\n* by SLASD3). This routine also calculates the singular vectors of\n* the current problem.\n*\n* The final stage consists of computing the updated singular vectors\n* directly using the updated singular values. The singular vectors\n* for the current problem are multiplied with the singular vectors\n* from the overall problem.\n*\n\n* Arguments\n* =========\n*\n* NL (input) INTEGER\n* The row dimension of the upper block. NL >= 1.\n*\n* NR (input) INTEGER\n* The row dimension of the lower block. NR >= 1.\n*\n* SQRE (input) INTEGER\n* = 0: the lower block is an NR-by-NR square matrix.\n* = 1: the lower block is an NR-by-(NR+1) rectangular matrix.\n*\n* The bidiagonal matrix has row dimension N = NL + NR + 1,\n* and column dimension M = N + SQRE.\n*\n* D (input/output) REAL array, dimension (NL+NR+1).\n* N = NL+NR+1\n* On entry D(1:NL,1:NL) contains the singular values of the\n* upper block; and D(NL+2:N) contains the singular values of\n* the lower block. On exit D(1:N) contains the singular values\n* of the modified matrix.\n*\n* ALPHA (input/output) REAL\n* Contains the diagonal element associated with the added row.\n*\n* BETA (input/output) REAL\n* Contains the off-diagonal element associated with the added\n* row.\n*\n* U (input/output) REAL array, dimension (LDU,N)\n* On entry U(1:NL, 1:NL) contains the left singular vectors of\n* the upper block; U(NL+2:N, NL+2:N) contains the left singular\n* vectors of the lower block. On exit U contains the left\n* singular vectors of the bidiagonal matrix.\n*\n* LDU (input) INTEGER\n* The leading dimension of the array U. LDU >= max( 1, N ).\n*\n* VT (input/output) REAL array, dimension (LDVT,M)\n* where M = N + SQRE.\n* On entry VT(1:NL+1, 1:NL+1)' contains the right singular\n* vectors of the upper block; VT(NL+2:M, NL+2:M)' contains\n* the right singular vectors of the lower block. On exit\n* VT' contains the right singular vectors of the\n* bidiagonal matrix.\n*\n* LDVT (input) INTEGER\n* The leading dimension of the array VT. LDVT >= max( 1, M ).\n*\n* IDXQ (output) INTEGER array, dimension (N)\n* This contains the permutation which will reintegrate the\n* subproblem just solved back into sorted order, i.e.\n* D( IDXQ( I = 1, N ) ) will be in ascending order.\n*\n* IWORK (workspace) INTEGER array, dimension (4*N)\n*\n* WORK (workspace) REAL array, dimension (3*M**2+2*M)\n*\n* INFO (output) INTEGER\n* = 0: successful exit.\n* < 0: if INFO = -i, the i-th argument had an illegal value.\n* > 0: if INFO = 1, a singular value did not converge\n*\n\n* Further Details\n* ===============\n*\n* Based on contributions by\n* Ming Gu and Huan Ren, Computer Science Division, University of\n* California at Berkeley, USA\n*\n* =====================================================================\n*\n\n");
|
|
48
48
|
return Qnil;
|
|
49
49
|
}
|
|
50
50
|
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
|
data/ext/slasd6.c
CHANGED
|
@@ -68,7 +68,7 @@ rblapack_slasd6(int argc, VALUE *argv, VALUE self){
|
|
|
68
68
|
argc--;
|
|
69
69
|
rblapack_options = argv[argc];
|
|
70
70
|
if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
|
|
71
|
-
printf("%s\n", "USAGE:\n idxq, perm, givptr, givcol, givnum, poles, difl, difr, z, k, c, s, info, d, vf, vl, alpha, beta = NumRu::Lapack.slasd6( icompq, nl, nr, sqre, d, vf, vl, alpha, beta, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLASD6( ICOMPQ, NL, NR, SQRE, D, VF, VL, ALPHA, BETA, IDXQ, PERM, GIVPTR, GIVCOL, LDGCOL, GIVNUM, LDGNUM, POLES, DIFL, DIFR, Z, K, C, S, WORK, IWORK, INFO )\n\n* Purpose\n* =======\n*\n* SLASD6 computes the SVD of an updated upper bidiagonal matrix B\n* obtained by merging two smaller ones by appending a row. This\n* routine is used only for the problem which requires all singular\n* values and optionally singular vector matrices in factored form.\n* B is an N-by-M matrix with N = NL + NR + 1 and M = N + SQRE.\n* A related subroutine, SLASD1, handles the case in which all singular\n* values and singular vectors of the bidiagonal matrix are desired.\n*\n* SLASD6 computes the SVD as follows:\n*\n* ( D1(in) 0 0 0 )\n* B = U(in) * ( Z1' a Z2' b ) * VT(in)\n* ( 0 0 D2(in) 0 )\n*\n* = U(out) * ( D(out) 0) * VT(out)\n*\n* where Z' = (Z1' a Z2' b) = u' VT', and u is a vector of dimension M\n* with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros\n* elsewhere; and the entry b is empty if SQRE = 0.\n*\n* The singular values of B can be computed using D1, D2, the first\n* components of all the right singular vectors of the lower block, and\n* the last components of all the right singular vectors of the upper\n* block. These components are stored and updated in VF and VL,\n* respectively, in SLASD6. Hence U and VT are not explicitly\n* referenced.\n*\n* The singular values are stored in D. The algorithm consists of two\n* stages:\n*\n* The first stage consists of deflating the size of the problem\n* when there are multiple singular values or if there is a zero\n* in the Z vector. For each such
|
|
71
|
+
printf("%s\n", "USAGE:\n idxq, perm, givptr, givcol, givnum, poles, difl, difr, z, k, c, s, info, d, vf, vl, alpha, beta = NumRu::Lapack.slasd6( icompq, nl, nr, sqre, d, vf, vl, alpha, beta, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE SLASD6( ICOMPQ, NL, NR, SQRE, D, VF, VL, ALPHA, BETA, IDXQ, PERM, GIVPTR, GIVCOL, LDGCOL, GIVNUM, LDGNUM, POLES, DIFL, DIFR, Z, K, C, S, WORK, IWORK, INFO )\n\n* Purpose\n* =======\n*\n* SLASD6 computes the SVD of an updated upper bidiagonal matrix B\n* obtained by merging two smaller ones by appending a row. This\n* routine is used only for the problem which requires all singular\n* values and optionally singular vector matrices in factored form.\n* B is an N-by-M matrix with N = NL + NR + 1 and M = N + SQRE.\n* A related subroutine, SLASD1, handles the case in which all singular\n* values and singular vectors of the bidiagonal matrix are desired.\n*\n* SLASD6 computes the SVD as follows:\n*\n* ( D1(in) 0 0 0 )\n* B = U(in) * ( Z1' a Z2' b ) * VT(in)\n* ( 0 0 D2(in) 0 )\n*\n* = U(out) * ( D(out) 0) * VT(out)\n*\n* where Z' = (Z1' a Z2' b) = u' VT', and u is a vector of dimension M\n* with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros\n* elsewhere; and the entry b is empty if SQRE = 0.\n*\n* The singular values of B can be computed using D1, D2, the first\n* components of all the right singular vectors of the lower block, and\n* the last components of all the right singular vectors of the upper\n* block. These components are stored and updated in VF and VL,\n* respectively, in SLASD6. Hence U and VT are not explicitly\n* referenced.\n*\n* The singular values are stored in D. The algorithm consists of two\n* stages:\n*\n* The first stage consists of deflating the size of the problem\n* when there are multiple singular values or if there is a zero\n* in the Z vector. For each such occurrence the dimension of the\n* secular equation problem is reduced by one. This stage is\n* performed by the routine SLASD7.\n*\n* The second stage consists of calculating the updated\n* singular values. This is done by finding the roots of the\n* secular equation via the routine SLASD4 (as called by SLASD8).\n* This routine also updates VF and VL and computes the distances\n* between the updated singular values and the old singular\n* values.\n*\n* SLASD6 is called from SLASDA.\n*\n\n* Arguments\n* =========\n*\n* ICOMPQ (input) INTEGER\n* Specifies whether singular vectors are to be computed in\n* factored form:\n* = 0: Compute singular values only.\n* = 1: Compute singular vectors in factored form as well.\n*\n* NL (input) INTEGER\n* The row dimension of the upper block. NL >= 1.\n*\n* NR (input) INTEGER\n* The row dimension of the lower block. NR >= 1.\n*\n* SQRE (input) INTEGER\n* = 0: the lower block is an NR-by-NR square matrix.\n* = 1: the lower block is an NR-by-(NR+1) rectangular matrix.\n*\n* The bidiagonal matrix has row dimension N = NL + NR + 1,\n* and column dimension M = N + SQRE.\n*\n* D (input/output) REAL array, dimension (NL+NR+1).\n* On entry D(1:NL,1:NL) contains the singular values of the\n* upper block, and D(NL+2:N) contains the singular values\n* of the lower block. On exit D(1:N) contains the singular\n* values of the modified matrix.\n*\n* VF (input/output) REAL array, dimension (M)\n* On entry, VF(1:NL+1) contains the first components of all\n* right singular vectors of the upper block; and VF(NL+2:M)\n* contains the first components of all right singular vectors\n* of the lower block. On exit, VF contains the first components\n* of all right singular vectors of the bidiagonal matrix.\n*\n* VL (input/output) REAL array, dimension (M)\n* On entry, VL(1:NL+1) contains the last components of all\n* right singular vectors of the upper block; and VL(NL+2:M)\n* contains the last components of all right singular vectors of\n* the lower block. On exit, VL contains the last components of\n* all right singular vectors of the bidiagonal matrix.\n*\n* ALPHA (input/output) REAL\n* Contains the diagonal element associated with the added row.\n*\n* BETA (input/output) REAL\n* Contains the off-diagonal element associated with the added\n* row.\n*\n* IDXQ (output) INTEGER array, dimension (N)\n* This contains the permutation which will reintegrate the\n* subproblem just solved back into sorted order, i.e.\n* D( IDXQ( I = 1, N ) ) will be in ascending order.\n*\n* PERM (output) INTEGER array, dimension ( N )\n* The permutations (from deflation and sorting) to be applied\n* to each block. Not referenced if ICOMPQ = 0.\n*\n* GIVPTR (output) INTEGER\n* The number of Givens rotations which took place in this\n* subproblem. Not referenced if ICOMPQ = 0.\n*\n* GIVCOL (output) INTEGER array, dimension ( LDGCOL, 2 )\n* Each pair of numbers indicates a pair of columns to take place\n* in a Givens rotation. Not referenced if ICOMPQ = 0.\n*\n* LDGCOL (input) INTEGER\n* leading dimension of GIVCOL, must be at least N.\n*\n* GIVNUM (output) REAL array, dimension ( LDGNUM, 2 )\n* Each number indicates the C or S value to be used in the\n* corresponding Givens rotation. Not referenced if ICOMPQ = 0.\n*\n* LDGNUM (input) INTEGER\n* The leading dimension of GIVNUM and POLES, must be at least N.\n*\n* POLES (output) REAL array, dimension ( LDGNUM, 2 )\n* On exit, POLES(1,*) is an array containing the new singular\n* values obtained from solving the secular equation, and\n* POLES(2,*) is an array containing the poles in the secular\n* equation. Not referenced if ICOMPQ = 0.\n*\n* DIFL (output) REAL array, dimension ( N )\n* On exit, DIFL(I) is the distance between I-th updated\n* (undeflated) singular value and the I-th (undeflated) old\n* singular value.\n*\n* DIFR (output) REAL array,\n* dimension ( LDGNUM, 2 ) if ICOMPQ = 1 and\n* dimension ( N ) if ICOMPQ = 0.\n* On exit, DIFR(I, 1) is the distance between I-th updated\n* (undeflated) singular value and the I+1-th (undeflated) old\n* singular value.\n*\n* If ICOMPQ = 1, DIFR(1:K,2) is an array containing the\n* normalizing factors for the right singular vector matrix.\n*\n* See SLASD8 for details on DIFL and DIFR.\n*\n* Z (output) REAL array, dimension ( M )\n* The first elements of this array contain the components\n* of the deflation-adjusted updating row vector.\n*\n* K (output) INTEGER\n* Contains the dimension of the non-deflated matrix,\n* This is the order of the related secular equation. 1 <= K <=N.\n*\n* C (output) REAL\n* C contains garbage if SQRE =0 and the C-value of a Givens\n* rotation related to the right null space if SQRE = 1.\n*\n* S (output) REAL\n* S contains garbage if SQRE =0 and the S-value of a Givens\n* rotation related to the right null space if SQRE = 1.\n*\n* WORK (workspace) REAL array, dimension ( 4 * M )\n*\n* IWORK (workspace) INTEGER array, dimension ( 3 * N )\n*\n* INFO (output) INTEGER\n* = 0: successful exit.\n* < 0: if INFO = -i, the i-th argument had an illegal value.\n* > 0: if INFO = 1, a singular value did not converge\n*\n\n* Further Details\n* ===============\n*\n* Based on contributions by\n* Ming Gu and Huan Ren, Computer Science Division, University of\n* California at Berkeley, USA\n*\n* =====================================================================\n*\n\n");
|
|
72
72
|
return Qnil;
|
|
73
73
|
}
|
|
74
74
|
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
|
data/ext/zlaed7.c
CHANGED
|
@@ -59,7 +59,7 @@ rblapack_zlaed7(int argc, VALUE *argv, VALUE self){
|
|
|
59
59
|
argc--;
|
|
60
60
|
rblapack_options = argv[argc];
|
|
61
61
|
if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
|
|
62
|
-
printf("%s\n", "USAGE:\n indxq, info, d, q, qstore, qptr = NumRu::Lapack.zlaed7( cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, rho, qstore, qptr, prmptr, perm, givptr, givcol, givnum, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE ZLAED7( N, CUTPNT, QSIZ, TLVLS, CURLVL, CURPBM, D, Q, LDQ, RHO, INDXQ, QSTORE, QPTR, PRMPTR, PERM, GIVPTR, GIVCOL, GIVNUM, WORK, RWORK, IWORK, INFO )\n\n* Purpose\n* =======\n*\n* ZLAED7 computes the updated eigensystem of a diagonal\n* matrix after modification by a rank-one symmetric matrix. This\n* routine is used only for the eigenproblem which requires all\n* eigenvalues and optionally eigenvectors of a dense or banded\n* Hermitian matrix that has been reduced to tridiagonal form.\n*\n* T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out)\n*\n* where Z = Q'u, u is a vector of length N with ones in the\n* CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.\n*\n* The eigenvectors of the original matrix are stored in Q, and the\n* eigenvalues are in D. The algorithm consists of three stages:\n*\n* The first stage consists of deflating the size of the problem\n* when there are multiple eigenvalues or if there is a zero in\n* the Z vector. For each such
|
|
62
|
+
printf("%s\n", "USAGE:\n indxq, info, d, q, qstore, qptr = NumRu::Lapack.zlaed7( cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, rho, qstore, qptr, prmptr, perm, givptr, givcol, givnum, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE ZLAED7( N, CUTPNT, QSIZ, TLVLS, CURLVL, CURPBM, D, Q, LDQ, RHO, INDXQ, QSTORE, QPTR, PRMPTR, PERM, GIVPTR, GIVCOL, GIVNUM, WORK, RWORK, IWORK, INFO )\n\n* Purpose\n* =======\n*\n* ZLAED7 computes the updated eigensystem of a diagonal\n* matrix after modification by a rank-one symmetric matrix. This\n* routine is used only for the eigenproblem which requires all\n* eigenvalues and optionally eigenvectors of a dense or banded\n* Hermitian matrix that has been reduced to tridiagonal form.\n*\n* T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out)\n*\n* where Z = Q'u, u is a vector of length N with ones in the\n* CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.\n*\n* The eigenvectors of the original matrix are stored in Q, and the\n* eigenvalues are in D. The algorithm consists of three stages:\n*\n* The first stage consists of deflating the size of the problem\n* when there are multiple eigenvalues or if there is a zero in\n* the Z vector. For each such occurrence the dimension of the\n* secular equation problem is reduced by one. This stage is\n* performed by the routine DLAED2.\n*\n* The second stage consists of calculating the updated\n* eigenvalues. This is done by finding the roots of the secular\n* equation via the routine DLAED4 (as called by SLAED3).\n* This routine also calculates the eigenvectors of the current\n* problem.\n*\n* The final stage consists of computing the updated eigenvectors\n* directly using the updated eigenvalues. The eigenvectors for\n* the current problem are multiplied with the eigenvectors from\n* the overall problem.\n*\n\n* Arguments\n* =========\n*\n* N (input) INTEGER\n* The dimension of the symmetric tridiagonal matrix. N >= 0.\n*\n* CUTPNT (input) INTEGER\n* Contains the location of the last eigenvalue in the leading\n* sub-matrix. min(1,N) <= CUTPNT <= N.\n*\n* QSIZ (input) INTEGER\n* The dimension of the unitary matrix used to reduce\n* the full matrix to tridiagonal form. QSIZ >= N.\n*\n* TLVLS (input) INTEGER\n* The total number of merging levels in the overall divide and\n* conquer tree.\n*\n* CURLVL (input) INTEGER\n* The current level in the overall merge routine,\n* 0 <= curlvl <= tlvls.\n*\n* CURPBM (input) INTEGER\n* The current problem in the current level in the overall\n* merge routine (counting from upper left to lower right).\n*\n* D (input/output) DOUBLE PRECISION array, dimension (N)\n* On entry, the eigenvalues of the rank-1-perturbed matrix.\n* On exit, the eigenvalues of the repaired matrix.\n*\n* Q (input/output) COMPLEX*16 array, dimension (LDQ,N)\n* On entry, the eigenvectors of the rank-1-perturbed matrix.\n* On exit, the eigenvectors of the repaired tridiagonal matrix.\n*\n* LDQ (input) INTEGER\n* The leading dimension of the array Q. LDQ >= max(1,N).\n*\n* RHO (input) DOUBLE PRECISION\n* Contains the subdiagonal element used to create the rank-1\n* modification.\n*\n* INDXQ (output) INTEGER array, dimension (N)\n* This contains the permutation which will reintegrate the\n* subproblem just solved back into sorted order,\n* ie. D( INDXQ( I = 1, N ) ) will be in ascending order.\n*\n* IWORK (workspace) INTEGER array, dimension (4*N)\n*\n* RWORK (workspace) DOUBLE PRECISION array,\n* dimension (3*N+2*QSIZ*N)\n*\n* WORK (workspace) COMPLEX*16 array, dimension (QSIZ*N)\n*\n* QSTORE (input/output) DOUBLE PRECISION array, dimension (N**2+1)\n* Stores eigenvectors of submatrices encountered during\n* divide and conquer, packed together. QPTR points to\n* beginning of the submatrices.\n*\n* QPTR (input/output) INTEGER array, dimension (N+2)\n* List of indices pointing to beginning of submatrices stored\n* in QSTORE. The submatrices are numbered starting at the\n* bottom left of the divide and conquer tree, from left to\n* right and bottom to top.\n*\n* PRMPTR (input) INTEGER array, dimension (N lg N)\n* Contains a list of pointers which indicate where in PERM a\n* level's permutation is stored. PRMPTR(i+1) - PRMPTR(i)\n* indicates the size of the permutation and also the size of\n* the full, non-deflated problem.\n*\n* PERM (input) INTEGER array, dimension (N lg N)\n* Contains the permutations (from deflation and sorting) to be\n* applied to each eigenblock.\n*\n* GIVPTR (input) INTEGER array, dimension (N lg N)\n* Contains a list of pointers which indicate where in GIVCOL a\n* level's Givens rotations are stored. GIVPTR(i+1) - GIVPTR(i)\n* indicates the number of Givens rotations.\n*\n* GIVCOL (input) INTEGER array, dimension (2, N lg N)\n* Each pair of numbers indicates a pair of columns to take place\n* in a Givens rotation.\n*\n* GIVNUM (input) DOUBLE PRECISION array, dimension (2, N lg N)\n* Each number indicates the S value to be used in the\n* corresponding Givens rotation.\n*\n* INFO (output) INTEGER\n* = 0: successful exit.\n* < 0: if INFO = -i, the i-th argument had an illegal value.\n* > 0: if INFO = 1, an eigenvalue did not converge\n*\n\n* =====================================================================\n*\n* .. Local Scalars ..\n INTEGER COLTYP, CURR, I, IDLMDA, INDX,\n $ INDXC, INDXP, IQ, IW, IZ, K, N1, N2, PTR\n* ..\n* .. External Subroutines ..\n EXTERNAL DLAED9, DLAEDA, DLAMRG, XERBLA, ZLACRM, ZLAED8\n* ..\n* .. Intrinsic Functions ..\n INTRINSIC MAX, MIN\n* ..\n\n");
|
|
63
63
|
return Qnil;
|
|
64
64
|
}
|
|
65
65
|
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
|
data/ext/zlag2c.c
CHANGED
|
@@ -23,7 +23,7 @@ rblapack_zlag2c(int argc, VALUE *argv, VALUE self){
|
|
|
23
23
|
argc--;
|
|
24
24
|
rblapack_options = argv[argc];
|
|
25
25
|
if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
|
|
26
|
-
printf("%s\n", "USAGE:\n sa, info = NumRu::Lapack.zlag2c( m, a, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE ZLAG2C( M, N, A, LDA, SA, LDSA, INFO )\n\n* Purpose\n* =======\n*\n* ZLAG2C converts a COMPLEX*16 matrix, SA, to a COMPLEX matrix, A.\n*\n* RMAX is the overflow for the SINGLE PRECISION arithmetic\n* ZLAG2C checks that all the entries of A are between -RMAX and\n* RMAX. If not the
|
|
26
|
+
printf("%s\n", "USAGE:\n sa, info = NumRu::Lapack.zlag2c( m, a, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE ZLAG2C( M, N, A, LDA, SA, LDSA, INFO )\n\n* Purpose\n* =======\n*\n* ZLAG2C converts a COMPLEX*16 matrix, SA, to a COMPLEX matrix, A.\n*\n* RMAX is the overflow for the SINGLE PRECISION arithmetic\n* ZLAG2C checks that all the entries of A are between -RMAX and\n* RMAX. If not the conversion is aborted and a flag is raised.\n*\n* This is an auxiliary routine so there is no argument checking.\n*\n\n* Arguments\n* =========\n*\n* M (input) INTEGER\n* The number of lines of the matrix A. M >= 0.\n*\n* N (input) INTEGER\n* The number of columns of the matrix A. N >= 0.\n*\n* A (input) COMPLEX*16 array, dimension (LDA,N)\n* On entry, the M-by-N coefficient matrix A.\n*\n* LDA (input) INTEGER\n* The leading dimension of the array A. LDA >= max(1,M).\n*\n* SA (output) COMPLEX array, dimension (LDSA,N)\n* On exit, if INFO=0, the M-by-N coefficient matrix SA; if\n* INFO>0, the content of SA is unspecified.\n*\n* LDSA (input) INTEGER\n* The leading dimension of the array SA. LDSA >= max(1,M).\n*\n* INFO (output) INTEGER\n* = 0: successful exit.\n* = 1: an entry of the matrix A is greater than the SINGLE\n* PRECISION overflow threshold, in this case, the content\n* of SA in exit is unspecified.\n*\n* =========\n*\n* .. Local Scalars ..\n INTEGER I, J\n DOUBLE PRECISION RMAX\n* ..\n* .. Intrinsic Functions ..\n INTRINSIC DBLE, DIMAG\n* ..\n* .. External Functions ..\n REAL SLAMCH\n EXTERNAL SLAMCH\n* ..\n\n");
|
|
27
27
|
return Qnil;
|
|
28
28
|
}
|
|
29
29
|
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
|
data/ext/zlarrv.c
CHANGED
|
@@ -68,7 +68,7 @@ rblapack_zlarrv(int argc, VALUE *argv, VALUE self){
|
|
|
68
68
|
argc--;
|
|
69
69
|
rblapack_options = argv[argc];
|
|
70
70
|
if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
|
|
71
|
-
printf("%s\n", "USAGE:\n z, isuppz, info, d, l, w, werr, wgap = NumRu::Lapack.zlarrv( vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE ZLARRV( N, VL, VU, D, L, PIVMIN, ISPLIT, M, DOL, DOU, MINRGP, RTOL1, RTOL2, W, WERR, WGAP, IBLOCK, INDEXW, GERS, Z, LDZ, ISUPPZ, WORK, IWORK, INFO )\n\n* Purpose\n* =======\n*\n* ZLARRV computes the eigenvectors of the tridiagonal matrix\n* T = L D L^T given L, D and APPROXIMATIONS to the eigenvalues of L D L^T.\n* The input eigenvalues should have been computed by DLARRE.\n*\n\n* Arguments\n* =========\n*\n* N (input) INTEGER\n* The order of the matrix. N >= 0.\n*\n* VL (input) DOUBLE PRECISION\n* VU (input) DOUBLE PRECISION\n* Lower and upper bounds of the interval that contains the desired\n* eigenvalues. VL < VU. Needed to compute gaps on the left or right\n* end of the extremal eigenvalues in the desired RANGE.\n*\n* D (input/output) DOUBLE PRECISION array, dimension (N)\n* On entry, the N diagonal elements of the diagonal matrix D.\n* On exit, D may be overwritten.\n*\n* L (input/output) DOUBLE PRECISION array, dimension (N)\n* On entry, the (N-1) subdiagonal elements of the unit\n* bidiagonal matrix L are in elements 1 to N-1 of L\n* (if the matrix is not
|
|
71
|
+
printf("%s\n", "USAGE:\n z, isuppz, info, d, l, w, werr, wgap = NumRu::Lapack.zlarrv( vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n SUBROUTINE ZLARRV( N, VL, VU, D, L, PIVMIN, ISPLIT, M, DOL, DOU, MINRGP, RTOL1, RTOL2, W, WERR, WGAP, IBLOCK, INDEXW, GERS, Z, LDZ, ISUPPZ, WORK, IWORK, INFO )\n\n* Purpose\n* =======\n*\n* ZLARRV computes the eigenvectors of the tridiagonal matrix\n* T = L D L^T given L, D and APPROXIMATIONS to the eigenvalues of L D L^T.\n* The input eigenvalues should have been computed by DLARRE.\n*\n\n* Arguments\n* =========\n*\n* N (input) INTEGER\n* The order of the matrix. N >= 0.\n*\n* VL (input) DOUBLE PRECISION\n* VU (input) DOUBLE PRECISION\n* Lower and upper bounds of the interval that contains the desired\n* eigenvalues. VL < VU. Needed to compute gaps on the left or right\n* end of the extremal eigenvalues in the desired RANGE.\n*\n* D (input/output) DOUBLE PRECISION array, dimension (N)\n* On entry, the N diagonal elements of the diagonal matrix D.\n* On exit, D may be overwritten.\n*\n* L (input/output) DOUBLE PRECISION array, dimension (N)\n* On entry, the (N-1) subdiagonal elements of the unit\n* bidiagonal matrix L are in elements 1 to N-1 of L\n* (if the matrix is not split.) At the end of each block\n* is stored the corresponding shift as given by DLARRE.\n* On exit, L is overwritten.\n*\n* PIVMIN (in) DOUBLE PRECISION\n* The minimum pivot allowed in the Sturm sequence.\n*\n* ISPLIT (input) INTEGER array, dimension (N)\n* The splitting points, at which T breaks up into blocks.\n* The first block consists of rows/columns 1 to\n* ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1\n* through ISPLIT( 2 ), etc.\n*\n* M (input) INTEGER\n* The total number of input eigenvalues. 0 <= M <= N.\n*\n* DOL (input) INTEGER\n* DOU (input) INTEGER\n* If the user wants to compute only selected eigenvectors from all\n* the eigenvalues supplied, he can specify an index range DOL:DOU.\n* Or else the setting DOL=1, DOU=M should be applied.\n* Note that DOL and DOU refer to the order in which the eigenvalues\n* are stored in W.\n* If the user wants to compute only selected eigenpairs, then\n* the columns DOL-1 to DOU+1 of the eigenvector space Z contain the\n* computed eigenvectors. All other columns of Z are set to zero.\n*\n* MINRGP (input) DOUBLE PRECISION\n*\n* RTOL1 (input) DOUBLE PRECISION\n* RTOL2 (input) DOUBLE PRECISION\n* Parameters for bisection.\n* An interval [LEFT,RIGHT] has converged if\n* RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )\n*\n* W (input/output) DOUBLE PRECISION array, dimension (N)\n* The first M elements of W contain the APPROXIMATE eigenvalues for\n* which eigenvectors are to be computed. The eigenvalues\n* should be grouped by split-off block and ordered from\n* smallest to largest within the block ( The output array\n* W from DLARRE is expected here ). Furthermore, they are with\n* respect to the shift of the corresponding root representation\n* for their block. On exit, W holds the eigenvalues of the\n* UNshifted matrix.\n*\n* WERR (input/output) DOUBLE PRECISION array, dimension (N)\n* The first M elements contain the semiwidth of the uncertainty\n* interval of the corresponding eigenvalue in W\n*\n* WGAP (input/output) DOUBLE PRECISION array, dimension (N)\n* The separation from the right neighbor eigenvalue in W.\n*\n* IBLOCK (input) INTEGER array, dimension (N)\n* The indices of the blocks (submatrices) associated with the\n* corresponding eigenvalues in W; IBLOCK(i)=1 if eigenvalue\n* W(i) belongs to the first block from the top, =2 if W(i)\n* belongs to the second block, etc.\n*\n* INDEXW (input) INTEGER array, dimension (N)\n* The indices of the eigenvalues within each block (submatrix);\n* for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the\n* i-th eigenvalue W(i) is the 10-th eigenvalue in the second block.\n*\n* GERS (input) DOUBLE PRECISION array, dimension (2*N)\n* The N Gerschgorin intervals (the i-th Gerschgorin interval\n* is (GERS(2*i-1), GERS(2*i)). The Gerschgorin intervals should\n* be computed from the original UNshifted matrix.\n*\n* Z (output) COMPLEX*16 array, dimension (LDZ, max(1,M) )\n* If INFO = 0, the first M columns of Z contain the\n* orthonormal eigenvectors of the matrix T\n* corresponding to the input eigenvalues, with the i-th\n* column of Z holding the eigenvector associated with W(i).\n* Note: the user must ensure that at least max(1,M) columns are\n* supplied in the array Z.\n*\n* LDZ (input) INTEGER\n* The leading dimension of the array Z. LDZ >= 1, and if\n* JOBZ = 'V', LDZ >= max(1,N).\n*\n* ISUPPZ (output) INTEGER array, dimension ( 2*max(1,M) )\n* The support of the eigenvectors in Z, i.e., the indices\n* indicating the nonzero elements in Z. The I-th eigenvector\n* is nonzero only in elements ISUPPZ( 2*I-1 ) through\n* ISUPPZ( 2*I ).\n*\n* WORK (workspace) DOUBLE PRECISION array, dimension (12*N)\n*\n* IWORK (workspace) INTEGER array, dimension (7*N)\n*\n* INFO (output) INTEGER\n* = 0: successful exit\n*\n* > 0: A problem occured in ZLARRV.\n* < 0: One of the called subroutines signaled an internal problem.\n* Needs inspection of the corresponding parameter IINFO\n* for further information.\n*\n* =-1: Problem in DLARRB when refining a child's eigenvalues.\n* =-2: Problem in DLARRF when computing the RRR of a child.\n* When a child is inside a tight cluster, it can be difficult\n* to find an RRR. A partial remedy from the user's point of\n* view is to make the parameter MINRGP smaller and recompile.\n* However, as the orthogonality of the computed vectors is\n* proportional to 1/MINRGP, the user should be aware that\n* he might be trading in precision when he decreases MINRGP.\n* =-3: Problem in DLARRB when refining a single eigenvalue\n* after the Rayleigh correction was rejected.\n* = 5: The Rayleigh Quotient Iteration failed to converge to\n* full accuracy in MAXITR steps.\n*\n\n* Further Details\n* ===============\n*\n* Based on contributions by\n* Beresford Parlett, University of California, Berkeley, USA\n* Jim Demmel, University of California, Berkeley, USA\n* Inderjit Dhillon, University of Texas, Austin, USA\n* Osni Marques, LBNL/NERSC, USA\n* Christof Voemel, University of California, Berkeley, USA\n*\n* =====================================================================\n*\n\n");
|
|
72
72
|
return Qnil;
|
|
73
73
|
}
|
|
74
74
|
if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
|
metadata
CHANGED
|
@@ -1,14 +1,14 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: ruby-lapack
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 1.7.
|
|
4
|
+
version: 1.7.2
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Seiya Nishizawa
|
|
8
8
|
autorequire:
|
|
9
9
|
bindir: bin
|
|
10
10
|
cert_chain: []
|
|
11
|
-
date:
|
|
11
|
+
date: 2016-02-08 00:00:00.000000000 Z
|
|
12
12
|
dependencies:
|
|
13
13
|
- !ruby/object:Gem::Dependency
|
|
14
14
|
name: narray
|
|
@@ -3342,7 +3342,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
|
|
|
3342
3342
|
version: '0'
|
|
3343
3343
|
requirements: []
|
|
3344
3344
|
rubyforge_project:
|
|
3345
|
-
rubygems_version: 2.
|
|
3345
|
+
rubygems_version: 2.4.8
|
|
3346
3346
|
signing_key:
|
|
3347
3347
|
specification_version: 4
|
|
3348
3348
|
summary: A Ruby wrapper of Lapack
|