ruby-lapack 1.7 → 1.7.1

data/ext/dhsein.c

@@ -0,0 +1,205 @@
+#include "rb_lapack.h"
+
+extern VOID dhsein_(char* side, char* eigsrc, char* initv, logical* select, integer* n, doublereal* h, integer* ldh, doublereal* wr, doublereal* wi, doublereal* vl, integer* ldvl, doublereal* vr, integer* ldvr, integer* mm, integer* m, doublereal* work, integer* ifaill, integer* ifailr, integer* info);
+
+
+static VALUE
+rblapack_dhsein(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_side;
+  char side; 
+  VALUE rblapack_eigsrc;
+  char eigsrc; 
+  VALUE rblapack_initv;
+  char initv; 
+  VALUE rblapack_select;
+  logical *select; 
+  VALUE rblapack_h;
+  doublereal *h; 
+  VALUE rblapack_wr;
+  doublereal *wr; 
+  VALUE rblapack_wi;
+  doublereal *wi; 
+  VALUE rblapack_vl;
+  doublereal *vl; 
+  VALUE rblapack_vr;
+  doublereal *vr; 
+  VALUE rblapack_m;
+  integer m; 
+  VALUE rblapack_ifaill;
+  integer *ifaill; 
+  VALUE rblapack_ifailr;
+  integer *ifailr; 
+  VALUE rblapack_info;
+  integer info; 
+  VALUE rblapack_select_out__;
+  logical *select_out__;
+  VALUE rblapack_wr_out__;
+  doublereal *wr_out__;
+  VALUE rblapack_vl_out__;
+  doublereal *vl_out__;
+  VALUE rblapack_vr_out__;
+  doublereal *vr_out__;
+  doublereal *work;
+
+  integer n;
+  integer ldh;
+  integer ldvl;
+  integer mm;
+  integer ldvr;
+
+  VALUE rblapack_options;
+  if (argc > 0 && TYPE(argv[argc-1]) == T_HASH) {
+    argc--;
+    rblapack_options = argv[argc];
+    if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
+      printf("%s\n", "USAGE:\n  m, ifaill, ifailr, info, select, wr, vl, vr = NumRu::Lapack.dhsein( side, eigsrc, initv, select, h, wr, wi, vl, vr, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DHSEIN( SIDE, EIGSRC, INITV, SELECT, N, H, LDH, WR, WI, VL, LDVL, VR, LDVR, MM, M, WORK, IFAILL, IFAILR, INFO )\n\n*  Purpose\n*  =======\n*\n*  DHSEIN uses inverse iteration to find specified right and/or left\n*  eigenvectors of a real upper Hessenberg matrix H.\n*\n*  The right eigenvector x and the left eigenvector y of the matrix H\n*  corresponding to an eigenvalue w are defined by:\n*\n*               H * x = w * x,     y**h * H = w * y**h\n*\n*  where y**h denotes the conjugate transpose of the vector y.\n*\n\n*  Arguments\n*  =========\n*\n*  SIDE    (input) CHARACTER*1\n*          = 'R': compute right eigenvectors only;\n*          = 'L': compute left eigenvectors only;\n*          = 'B': compute both right and left eigenvectors.\n*\n*  EIGSRC  (input) CHARACTER*1\n*          Specifies the source of eigenvalues supplied in (WR,WI):\n*          = 'Q': the eigenvalues were found using DHSEQR; thus, if\n*                 H has zero subdiagonal elements, and so is\n*                 block-triangular, then the j-th eigenvalue can be\n*                 assumed to be an eigenvalue of the block containing\n*                 the j-th row/column.  This property allows DHSEIN to\n*                 perform inverse iteration on just one diagonal block.\n*          = 'N': no assumptions are made on the correspondence\n*                 between eigenvalues and diagonal blocks.  In this\n*                 case, DHSEIN must always perform inverse iteration\n*                 using the whole matrix H.\n*\n*  INITV   (input) CHARACTER*1\n*          = 'N': no initial vectors are supplied;\n*          = 'U': user-supplied initial vectors are stored in the arrays\n*                 VL and/or VR.\n*\n*  SELECT  (input/output) LOGICAL array, dimension (N)\n*          Specifies the eigenvectors to be computed. To select the\n*          real eigenvector corresponding to a real eigenvalue WR(j),\n*          SELECT(j) must be set to .TRUE.. To select the complex\n*          eigenvector corresponding to a complex eigenvalue\n*          (WR(j),WI(j)), with complex conjugate (WR(j+1),WI(j+1)),\n*          either SELECT(j) or SELECT(j+1) or both must be set to\n*          .TRUE.; then on exit SELECT(j) is .TRUE. and SELECT(j+1) is\n*          .FALSE..\n*\n*  N       (input) INTEGER\n*          The order of the matrix H.  N >= 0.\n*\n*  H       (input) DOUBLE PRECISION array, dimension (LDH,N)\n*          The upper Hessenberg matrix H.\n*\n*  LDH     (input) INTEGER\n*          The leading dimension of the array H.  LDH >= max(1,N).\n*\n*  WR      (input/output) DOUBLE PRECISION array, dimension (N)\n*  WI      (input) DOUBLE PRECISION array, dimension (N)\n*          On entry, the real and imaginary parts of the eigenvalues of\n*          H; a complex conjugate pair of eigenvalues must be stored in\n*          consecutive elements of WR and WI.\n*          On exit, WR may have been altered since close eigenvalues\n*          are perturbed slightly in searching for independent\n*          eigenvectors.\n*\n*  VL      (input/output) DOUBLE PRECISION array, dimension (LDVL,MM)\n*          On entry, if INITV = 'U' and SIDE = 'L' or 'B', VL must\n*          contain starting vectors for the inverse iteration for the\n*          left eigenvectors; the starting vector for each eigenvector\n*          must be in the same column(s) in which the eigenvector will\n*          be stored.\n*          On exit, if SIDE = 'L' or 'B', the left eigenvectors\n*          specified by SELECT will be stored consecutively in the\n*          columns of VL, in the same order as their eigenvalues. A\n*          complex eigenvector corresponding to a complex eigenvalue is\n*          stored in two consecutive columns, the first holding the real\n*          part and the second the imaginary part.\n*          If SIDE = 'R', VL is not referenced.\n*\n*  LDVL    (input) INTEGER\n*          The leading dimension of the array VL.\n*          LDVL >= max(1,N) if SIDE = 'L' or 'B'; LDVL >= 1 otherwise.\n*\n*  VR      (input/output) DOUBLE PRECISION array, dimension (LDVR,MM)\n*          On entry, if INITV = 'U' and SIDE = 'R' or 'B', VR must\n*          contain starting vectors for the inverse iteration for the\n*          right eigenvectors; the starting vector for each eigenvector\n*          must be in the same column(s) in which the eigenvector will\n*          be stored.\n*          On exit, if SIDE = 'R' or 'B', the right eigenvectors\n*          specified by SELECT will be stored consecutively in the\n*          columns of VR, in the same order as their eigenvalues. A\n*          complex eigenvector corresponding to a complex eigenvalue is\n*          stored in two consecutive columns, the first holding the real\n*          part and the second the imaginary part.\n*          If SIDE = 'L', VR is not referenced.\n*\n*  LDVR    (input) INTEGER\n*          The leading dimension of the array VR.\n*          LDVR >= max(1,N) if SIDE = 'R' or 'B'; LDVR >= 1 otherwise.\n*\n*  MM      (input) INTEGER\n*          The number of columns in the arrays VL and/or VR. MM >= M.\n*\n*  M       (output) INTEGER\n*          The number of columns in the arrays VL and/or VR required to\n*          store the eigenvectors; each selected real eigenvector\n*          occupies one column and each selected complex eigenvector\n*          occupies two columns.\n*\n*  WORK    (workspace) DOUBLE PRECISION array, dimension ((N+2)*N)\n*\n*  IFAILL  (output) INTEGER array, dimension (MM)\n*          If SIDE = 'L' or 'B', IFAILL(i) = j > 0 if the left\n*          eigenvector in the i-th column of VL (corresponding to the\n*          eigenvalue w(j)) failed to converge; IFAILL(i) = 0 if the\n*          eigenvector converged satisfactorily. If the i-th and (i+1)th\n*          columns of VL hold a complex eigenvector, then IFAILL(i) and\n*          IFAILL(i+1) are set to the same value.\n*          If SIDE = 'R', IFAILL is not referenced.\n*\n*  IFAILR  (output) INTEGER array, dimension (MM)\n*          If SIDE = 'R' or 'B', IFAILR(i) = j > 0 if the right\n*          eigenvector in the i-th column of VR (corresponding to the\n*          eigenvalue w(j)) failed to converge; IFAILR(i) = 0 if the\n*          eigenvector converged satisfactorily. If the i-th and (i+1)th\n*          columns of VR hold a complex eigenvector, then IFAILR(i) and\n*          IFAILR(i+1) are set to the same value.\n*          If SIDE = 'L', IFAILR is not referenced.\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 = i, i is the number of eigenvectors which\n*                failed to converge; see IFAILL and IFAILR for further\n*                details.\n*\n\n*  Further Details\n*  ===============\n*\n*  Each eigenvector is normalized so that the element of largest\n*  magnitude has magnitude 1; here the magnitude of a complex number\n*  (x,y) is taken to be |x|+|y|.\n*\n*  =====================================================================\n*\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  m, ifaill, ifailr, info, select, wr, vl, vr = NumRu::Lapack.dhsein( side, eigsrc, initv, select, h, wr, wi, vl, vr, [:usage => usage, :help => help])\n");
+      return Qnil;
+    } 
+  } else
+    rblapack_options = Qnil;
+  if (argc != 9 && argc != 9)
+    rb_raise(rb_eArgError,"wrong number of arguments (%d for 9)", argc);
+  rblapack_side = argv[0];
+  rblapack_eigsrc = argv[1];
+  rblapack_initv = argv[2];
+  rblapack_select = argv[3];
+  rblapack_h = argv[4];
+  rblapack_wr = argv[5];
+  rblapack_wi = argv[6];
+  rblapack_vl = argv[7];
+  rblapack_vr = argv[8];
+  if (argc == 9) {
+  } else if (rblapack_options != Qnil) {
+  } else {
+  }
+
+  side = StringValueCStr(rblapack_side)[0];
+  initv = StringValueCStr(rblapack_initv)[0];
+  if (!NA_IsNArray(rblapack_h))
+    rb_raise(rb_eArgError, "h (5th argument) must be NArray");
+  if (NA_RANK(rblapack_h) != 2)
+    rb_raise(rb_eArgError, "rank of h (5th argument) must be %d", 2);
+  ldh = NA_SHAPE0(rblapack_h);
+  n = NA_SHAPE1(rblapack_h);
+  if (NA_TYPE(rblapack_h) != NA_DFLOAT)
+    rblapack_h = na_change_type(rblapack_h, NA_DFLOAT);
+  h = NA_PTR_TYPE(rblapack_h, doublereal*);
+  if (!NA_IsNArray(rblapack_wi))
+    rb_raise(rb_eArgError, "wi (7th argument) must be NArray");
+  if (NA_RANK(rblapack_wi) != 1)
+    rb_raise(rb_eArgError, "rank of wi (7th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_wi) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of wi must be the same as shape 1 of h");
+  if (NA_TYPE(rblapack_wi) != NA_DFLOAT)
+    rblapack_wi = na_change_type(rblapack_wi, NA_DFLOAT);
+  wi = NA_PTR_TYPE(rblapack_wi, doublereal*);
+  if (!NA_IsNArray(rblapack_vr))
+    rb_raise(rb_eArgError, "vr (9th argument) must be NArray");
+  if (NA_RANK(rblapack_vr) != 2)
+    rb_raise(rb_eArgError, "rank of vr (9th argument) must be %d", 2);
+  ldvr = NA_SHAPE0(rblapack_vr);
+  mm = NA_SHAPE1(rblapack_vr);
+  if (NA_TYPE(rblapack_vr) != NA_DFLOAT)
+    rblapack_vr = na_change_type(rblapack_vr, NA_DFLOAT);
+  vr = NA_PTR_TYPE(rblapack_vr, doublereal*);
+  eigsrc = StringValueCStr(rblapack_eigsrc)[0];
+  if (!NA_IsNArray(rblapack_wr))
+    rb_raise(rb_eArgError, "wr (6th argument) must be NArray");
+  if (NA_RANK(rblapack_wr) != 1)
+    rb_raise(rb_eArgError, "rank of wr (6th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_wr) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of wr must be the same as shape 1 of h");
+  if (NA_TYPE(rblapack_wr) != NA_DFLOAT)
+    rblapack_wr = na_change_type(rblapack_wr, NA_DFLOAT);
+  wr = NA_PTR_TYPE(rblapack_wr, doublereal*);
+  if (!NA_IsNArray(rblapack_select))
+    rb_raise(rb_eArgError, "select (4th argument) must be NArray");
+  if (NA_RANK(rblapack_select) != 1)
+    rb_raise(rb_eArgError, "rank of select (4th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_select) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of select must be the same as shape 1 of h");
+  if (NA_TYPE(rblapack_select) != NA_LINT)
+    rblapack_select = na_change_type(rblapack_select, NA_LINT);
+  select = NA_PTR_TYPE(rblapack_select, logical*);
+  if (!NA_IsNArray(rblapack_vl))
+    rb_raise(rb_eArgError, "vl (8th argument) must be NArray");
+  if (NA_RANK(rblapack_vl) != 2)
+    rb_raise(rb_eArgError, "rank of vl (8th argument) must be %d", 2);
+  ldvl = NA_SHAPE0(rblapack_vl);
+  if (NA_SHAPE1(rblapack_vl) != mm)
+    rb_raise(rb_eRuntimeError, "shape 1 of vl must be the same as shape 1 of vr");
+  if (NA_TYPE(rblapack_vl) != NA_DFLOAT)
+    rblapack_vl = na_change_type(rblapack_vl, NA_DFLOAT);
+  vl = NA_PTR_TYPE(rblapack_vl, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = mm;
+    rblapack_ifaill = na_make_object(NA_LINT, 1, shape, cNArray);
+  }
+  ifaill = NA_PTR_TYPE(rblapack_ifaill, integer*);
+  {
+    na_shape_t shape[1];
+    shape[0] = mm;
+    rblapack_ifailr = na_make_object(NA_LINT, 1, shape, cNArray);
+  }
+  ifailr = NA_PTR_TYPE(rblapack_ifailr, integer*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_select_out__ = na_make_object(NA_LINT, 1, shape, cNArray);
+  }
+  select_out__ = NA_PTR_TYPE(rblapack_select_out__, logical*);
+  MEMCPY(select_out__, select, logical, NA_TOTAL(rblapack_select));
+  rblapack_select = rblapack_select_out__;
+  select = select_out__;
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_wr_out__ = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  wr_out__ = NA_PTR_TYPE(rblapack_wr_out__, doublereal*);
+  MEMCPY(wr_out__, wr, doublereal, NA_TOTAL(rblapack_wr));
+  rblapack_wr = rblapack_wr_out__;
+  wr = wr_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = ldvl;
+    shape[1] = mm;
+    rblapack_vl_out__ = na_make_object(NA_DFLOAT, 2, shape, cNArray);
+  }
+  vl_out__ = NA_PTR_TYPE(rblapack_vl_out__, doublereal*);
+  MEMCPY(vl_out__, vl, doublereal, NA_TOTAL(rblapack_vl));
+  rblapack_vl = rblapack_vl_out__;
+  vl = vl_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = ldvr;
+    shape[1] = mm;
+    rblapack_vr_out__ = na_make_object(NA_DFLOAT, 2, shape, cNArray);
+  }
+  vr_out__ = NA_PTR_TYPE(rblapack_vr_out__, doublereal*);
+  MEMCPY(vr_out__, vr, doublereal, NA_TOTAL(rblapack_vr));
+  rblapack_vr = rblapack_vr_out__;
+  vr = vr_out__;
+  work = ALLOC_N(doublereal, ((n+2)*n));
+
+  dhsein_(&side, &eigsrc, &initv, select, &n, h, &ldh, wr, wi, vl, &ldvl, vr, &ldvr, &mm, &m, work, ifaill, ifailr, &info);
+
+  free(work);
+  rblapack_m = INT2NUM(m);
+  rblapack_info = INT2NUM(info);
+  return rb_ary_new3(8, rblapack_m, rblapack_ifaill, rblapack_ifailr, rblapack_info, rblapack_select, rblapack_wr, rblapack_vl, rblapack_vr);
+}
+
+void
+init_lapack_dhsein(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "dhsein", rblapack_dhsein, -1);
+}

data/ext/dhseqr.c

@@ -0,0 +1,153 @@
+#include "rb_lapack.h"
+
+extern VOID dhseqr_(char* job, char* compz, integer* n, integer* ilo, integer* ihi, doublereal* h, integer* ldh, doublereal* wr, doublereal* wi, doublereal* z, integer* ldz, doublereal* work, integer* lwork, integer* info);
+
+
+static VALUE
+rblapack_dhseqr(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_job;
+  char job; 
+  VALUE rblapack_compz;
+  char compz; 
+  VALUE rblapack_ilo;
+  integer ilo; 
+  VALUE rblapack_ihi;
+  integer ihi; 
+  VALUE rblapack_h;
+  doublereal *h; 
+  VALUE rblapack_z;
+  doublereal *z; 
+  VALUE rblapack_ldz;
+  integer ldz; 
+  VALUE rblapack_lwork;
+  integer lwork; 
+  VALUE rblapack_wr;
+  doublereal *wr; 
+  VALUE rblapack_wi;
+  doublereal *wi; 
+  VALUE rblapack_work;
+  doublereal *work; 
+  VALUE rblapack_info;
+  integer info; 
+  VALUE rblapack_h_out__;
+  doublereal *h_out__;
+  VALUE rblapack_z_out__;
+  doublereal *z_out__;
+
+  integer ldh;
+  integer n;
+
+  VALUE rblapack_options;
+  if (argc > 0 && TYPE(argv[argc-1]) == T_HASH) {
+    argc--;
+    rblapack_options = argv[argc];
+    if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
+      printf("%s\n", "USAGE:\n  wr, wi, work, info, h, z = NumRu::Lapack.dhseqr( job, compz, ilo, ihi, h, z, ldz, [:lwork => lwork, :usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DHSEQR( JOB, COMPZ, N, ILO, IHI, H, LDH, WR, WI, Z, LDZ, WORK, LWORK, INFO )\n\n*     Purpose\n*     =======\n*\n*     DHSEQR computes the eigenvalues of a Hessenberg matrix H\n*     and, optionally, the matrices T and Z from the Schur decomposition\n*     H = Z T Z**T, where T is an upper quasi-triangular matrix (the\n*     Schur form), and Z is the orthogonal matrix of Schur vectors.\n*\n*     Optionally Z may be postmultiplied into an input orthogonal\n*     matrix Q so that this routine can give the Schur factorization\n*     of a matrix A which has been reduced to the Hessenberg form H\n*     by the orthogonal matrix Q:  A = Q*H*Q**T = (QZ)*T*(QZ)**T.\n*\n\n*     Arguments\n*     =========\n*\n*     JOB   (input) CHARACTER*1\n*           = 'E':  compute eigenvalues only;\n*           = 'S':  compute eigenvalues and the Schur form T.\n*\n*     COMPZ (input) CHARACTER*1\n*           = 'N':  no Schur vectors are computed;\n*           = 'I':  Z is initialized to the unit matrix and the matrix Z\n*                   of Schur vectors of H is returned;\n*           = 'V':  Z must contain an orthogonal matrix Q on entry, and\n*                   the product Q*Z is returned.\n*\n*     N     (input) INTEGER\n*           The order of the matrix H.  N .GE. 0.\n*\n*     ILO   (input) INTEGER\n*     IHI   (input) INTEGER\n*           It is assumed that H is already upper triangular in rows\n*           and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally\n*           set by a previous call to DGEBAL, and then passed to DGEHRD\n*           when the matrix output by DGEBAL is reduced to Hessenberg\n*           form. Otherwise ILO and IHI should be set to 1 and N\n*           respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.\n*           If N = 0, then ILO = 1 and IHI = 0.\n*\n*     H     (input/output) DOUBLE PRECISION array, dimension (LDH,N)\n*           On entry, the upper Hessenberg matrix H.\n*           On exit, if INFO = 0 and JOB = 'S', then H contains the\n*           upper quasi-triangular matrix T from the Schur decomposition\n*           (the Schur form); 2-by-2 diagonal blocks (corresponding to\n*           complex conjugate pairs of eigenvalues) are returned in\n*           standard form, with H(i,i) = H(i+1,i+1) and\n*           H(i+1,i)*H(i,i+1).LT.0. If INFO = 0 and JOB = 'E', the\n*           contents of H are unspecified on exit.  (The output value of\n*           H when INFO.GT.0 is given under the description of INFO\n*           below.)\n*\n*           Unlike earlier versions of DHSEQR, this subroutine may\n*           explicitly H(i,j) = 0 for i.GT.j and j = 1, 2, ... ILO-1\n*           or j = IHI+1, IHI+2, ... N.\n*\n*     LDH   (input) INTEGER\n*           The leading dimension of the array H. LDH .GE. max(1,N).\n*\n*     WR    (output) DOUBLE PRECISION array, dimension (N)\n*     WI    (output) DOUBLE PRECISION array, dimension (N)\n*           The real and imaginary parts, respectively, of the computed\n*           eigenvalues. If two eigenvalues are computed as a complex\n*           conjugate pair, they are stored in consecutive elements of\n*           WR and WI, say the i-th and (i+1)th, with WI(i) .GT. 0 and\n*           WI(i+1) .LT. 0. If JOB = 'S', the eigenvalues are stored in\n*           the same order as on the diagonal of the Schur form returned\n*           in H, with WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2\n*           diagonal block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and\n*           WI(i+1) = -WI(i).\n*\n*     Z     (input/output) DOUBLE PRECISION array, dimension (LDZ,N)\n*           If COMPZ = 'N', Z is not referenced.\n*           If COMPZ = 'I', on entry Z need not be set and on exit,\n*           if INFO = 0, Z contains the orthogonal matrix Z of the Schur\n*           vectors of H.  If COMPZ = 'V', on entry Z must contain an\n*           N-by-N matrix Q, which is assumed to be equal to the unit\n*           matrix except for the submatrix Z(ILO:IHI,ILO:IHI). On exit,\n*           if INFO = 0, Z contains Q*Z.\n*           Normally Q is the orthogonal matrix generated by DORGHR\n*           after the call to DGEHRD which formed the Hessenberg matrix\n*           H. (The output value of Z when INFO.GT.0 is given under\n*           the description of INFO below.)\n*\n*     LDZ   (input) INTEGER\n*           The leading dimension of the array Z.  if COMPZ = 'I' or\n*           COMPZ = 'V', then LDZ.GE.MAX(1,N).  Otherwize, LDZ.GE.1.\n*\n*     WORK  (workspace/output) DOUBLE PRECISION array, dimension (LWORK)\n*           On exit, if INFO = 0, WORK(1) returns an estimate of\n*           the optimal value for LWORK.\n*\n*     LWORK (input) INTEGER\n*           The dimension of the array WORK.  LWORK .GE. max(1,N)\n*           is sufficient and delivers very good and sometimes\n*           optimal performance.  However, LWORK as large as 11*N\n*           may be required for optimal performance.  A workspace\n*           query is recommended to determine the optimal workspace\n*           size.\n*\n*           If LWORK = -1, then DHSEQR does a workspace query.\n*           In this case, DHSEQR checks the input parameters and\n*           estimates the optimal workspace size for the given\n*           values of N, ILO and IHI.  The estimate is returned\n*           in WORK(1).  No error message related to LWORK is\n*           issued by XERBLA.  Neither H nor Z are accessed.\n*\n*\n*     INFO  (output) INTEGER\n*             =  0:  successful exit\n*           .LT. 0:  if INFO = -i, the i-th argument had an illegal\n*                    value\n*           .GT. 0:  if INFO = i, DHSEQR failed to compute all of\n*                the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR\n*                and WI contain those eigenvalues which have been\n*                successfully computed.  (Failures are rare.)\n*\n*                If INFO .GT. 0 and JOB = 'E', then on exit, the\n*                remaining unconverged eigenvalues are the eigen-\n*                values of the upper Hessenberg matrix rows and\n*                columns ILO through INFO of the final, output\n*                value of H.\n*\n*                If INFO .GT. 0 and JOB   = 'S', then on exit\n*\n*           (*)  (initial value of H)*U  = U*(final value of H)\n*\n*                where U is an orthogonal matrix.  The final\n*                value of H is upper Hessenberg and quasi-triangular\n*                in rows and columns INFO+1 through IHI.\n*\n*                If INFO .GT. 0 and COMPZ = 'V', then on exit\n*\n*                  (final value of Z)  =  (initial value of Z)*U\n*\n*                where U is the orthogonal matrix in (*) (regard-\n*                less of the value of JOB.)\n*\n*                If INFO .GT. 0 and COMPZ = 'I', then on exit\n*                      (final value of Z)  = U\n*                where U is the orthogonal matrix in (*) (regard-\n*                less of the value of JOB.)\n*\n*                If INFO .GT. 0 and COMPZ = 'N', then Z is not\n*                accessed.\n*\n\n*     ================================================================\n*             Default values supplied by\n*             ILAENV(ISPEC,'DHSEQR',JOB(:1)//COMPZ(:1),N,ILO,IHI,LWORK).\n*             It is suggested that these defaults be adjusted in order\n*             to attain best performance in each particular\n*             computational environment.\n*\n*            ISPEC=12: The DLAHQR vs DLAQR0 crossover point.\n*                      Default: 75. (Must be at least 11.)\n*\n*            ISPEC=13: Recommended deflation window size.\n*                      This depends on ILO, IHI and NS.  NS is the\n*                      number of simultaneous shifts returned\n*                      by ILAENV(ISPEC=15).  (See ISPEC=15 below.)\n*                      The default for (IHI-ILO+1).LE.500 is NS.\n*                      The default for (IHI-ILO+1).GT.500 is 3*NS/2.\n*\n*            ISPEC=14: Nibble crossover point. (See IPARMQ for\n*                      details.)  Default: 14% of deflation window\n*                      size.\n*\n*            ISPEC=15: Number of simultaneous shifts in a multishift\n*                      QR iteration.\n*\n*                      If IHI-ILO+1 is ...\n*\n*                      greater than      ...but less    ... the\n*                      or equal to ...      than        default is\n*\n*                           1               30          NS =   2(+)\n*                          30               60          NS =   4(+)\n*                          60              150          NS =  10(+)\n*                         150              590          NS =  **\n*                         590             3000          NS =  64\n*                        3000             6000          NS = 128\n*                        6000             infinity      NS = 256\n*\n*                  (+)  By default some or all matrices of this order\n*                       are passed to the implicit double shift routine\n*                       DLAHQR and this parameter is ignored.  See\n*                       ISPEC=12 above and comments in IPARMQ for\n*                       details.\n*\n*                 (**)  The asterisks (**) indicate an ad-hoc\n*                       function of N increasing from 10 to 64.\n*\n*            ISPEC=16: Select structured matrix multiply.\n*                      If the number of simultaneous shifts (specified\n*                      by ISPEC=15) is less than 14, then the default\n*                      for ISPEC=16 is 0.  Otherwise the default for\n*                      ISPEC=16 is 2.\n*\n*     ================================================================\n*     Based on contributions by\n*        Karen Braman and Ralph Byers, Department of Mathematics,\n*        University of Kansas, USA\n*\n*     ================================================================\n*     References:\n*       K. Braman, R. Byers and R. Mathias, The Multi-Shift QR\n*       Algorithm Part I: Maintaining Well Focused Shifts, and Level 3\n*       Performance, SIAM Journal of Matrix Analysis, volume 23, pages\n*       929--947, 2002.\n*\n*       K. Braman, R. Byers and R. Mathias, The Multi-Shift QR\n*       Algorithm Part II: Aggressive Early Deflation, SIAM Journal\n*       of Matrix Analysis, volume 23, pages 948--973, 2002.\n*\n*     ================================================================\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  wr, wi, work, info, h, z = NumRu::Lapack.dhseqr( job, compz, ilo, ihi, h, z, ldz, [:lwork => lwork, :usage => usage, :help => help])\n");
+      return Qnil;
+    } 
+  } else
+    rblapack_options = Qnil;
+  if (argc != 7 && argc != 8)
+    rb_raise(rb_eArgError,"wrong number of arguments (%d for 7)", argc);
+  rblapack_job = argv[0];
+  rblapack_compz = argv[1];
+  rblapack_ilo = argv[2];
+  rblapack_ihi = argv[3];
+  rblapack_h = argv[4];
+  rblapack_z = argv[5];
+  rblapack_ldz = argv[6];
+  if (argc == 8) {
+    rblapack_lwork = argv[7];
+  } else if (rblapack_options != Qnil) {
+    rblapack_lwork = rb_hash_aref(rblapack_options, ID2SYM(rb_intern("lwork")));
+  } else {
+    rblapack_lwork = Qnil;
+  }
+
+  job = StringValueCStr(rblapack_job)[0];
+  ilo = NUM2INT(rblapack_ilo);
+  if (!NA_IsNArray(rblapack_h))
+    rb_raise(rb_eArgError, "h (5th argument) must be NArray");
+  if (NA_RANK(rblapack_h) != 2)
+    rb_raise(rb_eArgError, "rank of h (5th argument) must be %d", 2);
+  ldh = NA_SHAPE0(rblapack_h);
+  n = NA_SHAPE1(rblapack_h);
+  if (NA_TYPE(rblapack_h) != NA_DFLOAT)
+    rblapack_h = na_change_type(rblapack_h, NA_DFLOAT);
+  h = NA_PTR_TYPE(rblapack_h, doublereal*);
+  ldz = NUM2INT(rblapack_ldz);
+  compz = StringValueCStr(rblapack_compz)[0];
+  if (!NA_IsNArray(rblapack_z))
+    rb_raise(rb_eArgError, "z (6th argument) must be NArray");
+  if (NA_RANK(rblapack_z) != 2)
+    rb_raise(rb_eArgError, "rank of z (6th argument) must be %d", 2);
+  if (NA_SHAPE0(rblapack_z) != (lsame_(&compz,"N") ? 0 : ldz))
+    rb_raise(rb_eRuntimeError, "shape 0 of z must be %d", lsame_(&compz,"N") ? 0 : ldz);
+  if (NA_SHAPE1(rblapack_z) != (lsame_(&compz,"N") ? 0 : n))
+    rb_raise(rb_eRuntimeError, "shape 1 of z must be %d", lsame_(&compz,"N") ? 0 : n);
+  if (NA_TYPE(rblapack_z) != NA_DFLOAT)
+    rblapack_z = na_change_type(rblapack_z, NA_DFLOAT);
+  z = NA_PTR_TYPE(rblapack_z, doublereal*);
+  ihi = NUM2INT(rblapack_ihi);
+  if (rblapack_lwork == Qnil)
+    lwork = n;
+  else {
+    lwork = NUM2INT(rblapack_lwork);
+  }
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_wr = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  wr = NA_PTR_TYPE(rblapack_wr, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_wi = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  wi = NA_PTR_TYPE(rblapack_wi, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = MAX(1,lwork);
+    rblapack_work = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  work = NA_PTR_TYPE(rblapack_work, doublereal*);
+  {
+    na_shape_t shape[2];
+    shape[0] = ldh;
+    shape[1] = n;
+    rblapack_h_out__ = na_make_object(NA_DFLOAT, 2, shape, cNArray);
+  }
+  h_out__ = NA_PTR_TYPE(rblapack_h_out__, doublereal*);
+  MEMCPY(h_out__, h, doublereal, NA_TOTAL(rblapack_h));
+  rblapack_h = rblapack_h_out__;
+  h = h_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = lsame_(&compz,"N") ? 0 : ldz;
+    shape[1] = lsame_(&compz,"N") ? 0 : n;
+    rblapack_z_out__ = na_make_object(NA_DFLOAT, 2, shape, cNArray);
+  }
+  z_out__ = NA_PTR_TYPE(rblapack_z_out__, doublereal*);
+  MEMCPY(z_out__, z, doublereal, NA_TOTAL(rblapack_z));
+  rblapack_z = rblapack_z_out__;
+  z = z_out__;
+
+  dhseqr_(&job, &compz, &n, &ilo, &ihi, h, &ldh, wr, wi, z, &ldz, work, &lwork, &info);
+
+  rblapack_info = INT2NUM(info);
+  return rb_ary_new3(6, rblapack_wr, rblapack_wi, rblapack_work, rblapack_info, rblapack_h, rblapack_z);
+}
+
+void
+init_lapack_dhseqr(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "dhseqr", rblapack_dhseqr, -1);
+}

data/ext/disnan.c

@@ -0,0 +1,51 @@
+#include "rb_lapack.h"
+
+extern logical disnan_(doublereal* din);
+
+
+static VALUE
+rblapack_disnan(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_din;
+  doublereal din; 
+  VALUE rblapack___out__;
+  logical __out__; 
+
+
+  VALUE rblapack_options;
+  if (argc > 0 && TYPE(argv[argc-1]) == T_HASH) {
+    argc--;
+    rblapack_options = argv[argc];
+    if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
+      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.disnan( din, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      LOGICAL FUNCTION DISNAN( DIN )\n\n*  Purpose\n*  =======\n*\n*  DISNAN returns .TRUE. if its argument is NaN, and .FALSE.\n*  otherwise.  To be replaced by the Fortran 2003 intrinsic in the\n*  future.\n*\n\n*  Arguments\n*  =========\n*\n*  DIN     (input) DOUBLE PRECISION\n*          Input to test for NaN.\n*\n\n*  =====================================================================\n*\n*  .. External Functions ..\n      LOGICAL DLAISNAN\n      EXTERNAL DLAISNAN\n*  ..\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.disnan( din, [:usage => usage, :help => help])\n");
+      return Qnil;
+    } 
+  } else
+    rblapack_options = Qnil;
+  if (argc != 1 && argc != 1)
+    rb_raise(rb_eArgError,"wrong number of arguments (%d for 1)", argc);
+  rblapack_din = argv[0];
+  if (argc == 1) {
+  } else if (rblapack_options != Qnil) {
+  } else {
+  }
+
+  din = NUM2DBL(rblapack_din);
+
+  __out__ = disnan_(&din);
+
+  rblapack___out__ = __out__ ? Qtrue : Qfalse;
+  return rblapack___out__;
+}
+
+void
+init_lapack_disnan(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "disnan", rblapack_disnan, -1);
+}

data/ext/dla_gbamv.c

@@ -0,0 +1,129 @@
+#include "rb_lapack.h"
+
+extern VOID dla_gbamv_(integer* trans, integer* m, integer* n, integer* kl, integer* ku, doublereal* alpha, doublereal* ab, integer* ldab, doublereal* x, integer* incx, doublereal* beta, doublereal* y, integer* incy);
+
+
+static VALUE
+rblapack_dla_gbamv(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_trans;
+  integer trans; 
+  VALUE rblapack_m;
+  integer m; 
+  VALUE rblapack_n;
+  integer n; 
+  VALUE rblapack_kl;
+  integer kl; 
+  VALUE rblapack_ku;
+  integer ku; 
+  VALUE rblapack_alpha;
+  doublereal alpha; 
+  VALUE rblapack_ab;
+  doublereal *ab; 
+  VALUE rblapack_x;
+  doublereal *x; 
+  VALUE rblapack_incx;
+  integer incx; 
+  VALUE rblapack_beta;
+  doublereal beta; 
+  VALUE rblapack_y;
+  doublereal *y; 
+  VALUE rblapack_incy;
+  integer incy; 
+  VALUE rblapack_y_out__;
+  doublereal *y_out__;
+
+  integer ldab;
+  integer lda;
+
+  VALUE rblapack_options;
+  if (argc > 0 && TYPE(argv[argc-1]) == T_HASH) {
+    argc--;
+    rblapack_options = argv[argc];
+    if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
+      printf("%s\n", "USAGE:\n  y = NumRu::Lapack.dla_gbamv( trans, m, n, kl, ku, alpha, ab, x, incx, beta, y, incy, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLA_GBAMV( TRANS, M, N, KL, KU, ALPHA, AB, LDAB, X, INCX, BETA, Y, INCY )\n\n*  Purpose\n*  =======\n*\n*  DLA_GBAMV  performs one of the matrix-vector operations\n*\n*          y := alpha*abs(A)*abs(x) + beta*abs(y),\n*     or   y := alpha*abs(A)'*abs(x) + beta*abs(y),\n*\n*  where alpha and beta are scalars, x and y are vectors and A is an\n*  m by n matrix.\n*\n*  This function is primarily used in calculating error bounds.\n*  To protect against underflow during evaluation, components in\n*  the resulting vector are perturbed away from zero by (N+1)\n*  times the underflow threshold.  To prevent unnecessarily large\n*  errors for block-structure embedded in general matrices,\n*  \"symbolically\" zero components are not perturbed.  A zero\n*  entry is considered \"symbolic\" if all multiplications involved\n*  in computing that entry have at least one zero multiplicand.\n*\n\n*  Arguments\n*  ==========\n*\n*  TRANS   (input) INTEGER\n*           On entry, TRANS specifies the operation to be performed as\n*           follows:\n*\n*             BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)\n*             BLAS_TRANS         y := alpha*abs(A')*abs(x) + beta*abs(y)\n*             BLAS_CONJ_TRANS    y := alpha*abs(A')*abs(x) + beta*abs(y)\n*\n*           Unchanged on exit.\n*\n*  M       (input) INTEGER\n*           On entry, M specifies the number of rows of the matrix A.\n*           M must be at least zero.\n*           Unchanged on exit.\n*\n*  N       (input) INTEGER\n*           On entry, N specifies the number of columns of the matrix A.\n*           N must be at least zero.\n*           Unchanged on exit.\n*\n*  KL      (input) INTEGER\n*           The number of subdiagonals within the band of A.  KL >= 0.\n*\n*  KU      (input) INTEGER\n*           The number of superdiagonals within the band of A.  KU >= 0.\n*\n*  ALPHA  - DOUBLE PRECISION\n*           On entry, ALPHA specifies the scalar alpha.\n*           Unchanged on exit.\n*\n*  A      - DOUBLE PRECISION   array of DIMENSION ( LDA, n )\n*           Before entry, the leading m by n part of the array A must\n*           contain the matrix of coefficients.\n*           Unchanged on exit.\n*\n*  LDA     (input) INTEGER\n*           On entry, LDA specifies the first dimension of A as declared\n*           in the calling (sub) program. LDA must be at least\n*           max( 1, m ).\n*           Unchanged on exit.\n*\n*  X       (input) DOUBLE PRECISION array, dimension\n*           ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'\n*           and at least\n*           ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.\n*           Before entry, the incremented array X must contain the\n*           vector x.\n*           Unchanged on exit.\n*\n*  INCX    (input) INTEGER\n*           On entry, INCX specifies the increment for the elements of\n*           X. INCX must not be zero.\n*           Unchanged on exit.\n*\n*  BETA   - DOUBLE PRECISION\n*           On entry, BETA specifies the scalar beta. When BETA is\n*           supplied as zero then Y need not be set on input.\n*           Unchanged on exit.\n*\n*  Y       (input/output) DOUBLE PRECISION  array, dimension\n*           ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'\n*           and at least\n*           ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.\n*           Before entry with BETA non-zero, the incremented array Y\n*           must contain the vector y. On exit, Y is overwritten by the\n*           updated vector y.\n*\n*  INCY    (input) INTEGER\n*           On entry, INCY specifies the increment for the elements of\n*           Y. INCY must not be zero.\n*           Unchanged on exit.\n*\n*\n*  Level 2 Blas routine.\n*\n\n*  =====================================================================\n\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  y = NumRu::Lapack.dla_gbamv( trans, m, n, kl, ku, alpha, ab, x, incx, beta, y, incy, [:usage => usage, :help => help])\n");
+      return Qnil;
+    } 
+  } else
+    rblapack_options = Qnil;
+  if (argc != 12 && argc != 12)
+    rb_raise(rb_eArgError,"wrong number of arguments (%d for 12)", argc);
+  rblapack_trans = argv[0];
+  rblapack_m = argv[1];
+  rblapack_n = argv[2];
+  rblapack_kl = argv[3];
+  rblapack_ku = argv[4];
+  rblapack_alpha = argv[5];
+  rblapack_ab = argv[6];
+  rblapack_x = argv[7];
+  rblapack_incx = argv[8];
+  rblapack_beta = argv[9];
+  rblapack_y = argv[10];
+  rblapack_incy = argv[11];
+  if (argc == 12) {
+  } else if (rblapack_options != Qnil) {
+  } else {
+  }
+
+  trans = NUM2INT(rblapack_trans);
+  n = NUM2INT(rblapack_n);
+  ku = NUM2INT(rblapack_ku);
+  if (!NA_IsNArray(rblapack_ab))
+    rb_raise(rb_eArgError, "ab (7th argument) must be NArray");
+  if (NA_RANK(rblapack_ab) != 1)
+    rb_raise(rb_eArgError, "rank of ab (7th argument) must be %d", 1);
+  ldab = NA_SHAPE0(rblapack_ab);
+  if (NA_TYPE(rblapack_ab) != NA_DFLOAT)
+    rblapack_ab = na_change_type(rblapack_ab, NA_DFLOAT);
+  ab = NA_PTR_TYPE(rblapack_ab, doublereal*);
+  incx = NUM2INT(rblapack_incx);
+  incy = NUM2INT(rblapack_incy);
+  m = NUM2INT(rblapack_m);
+  alpha = NUM2DBL(rblapack_alpha);
+  beta = NUM2DBL(rblapack_beta);
+  lda = MAX( 1, m );
+  kl = NUM2INT(rblapack_kl);
+  if (!NA_IsNArray(rblapack_y))
+    rb_raise(rb_eArgError, "y (11th argument) must be NArray");
+  if (NA_RANK(rblapack_y) != 1)
+    rb_raise(rb_eArgError, "rank of y (11th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_y) != (trans == ilatrans_("N") ? 1 + ( m - 1 )*abs( incy ) : 1 + ( n - 1 )*abs( incy )))
+    rb_raise(rb_eRuntimeError, "shape 0 of y must be %d", trans == ilatrans_("N") ? 1 + ( m - 1 )*abs( incy ) : 1 + ( n - 1 )*abs( incy ));
+  if (NA_TYPE(rblapack_y) != NA_DFLOAT)
+    rblapack_y = na_change_type(rblapack_y, NA_DFLOAT);
+  y = NA_PTR_TYPE(rblapack_y, doublereal*);
+  if (!NA_IsNArray(rblapack_x))
+    rb_raise(rb_eArgError, "x (8th argument) must be NArray");
+  if (NA_RANK(rblapack_x) != 1)
+    rb_raise(rb_eArgError, "rank of x (8th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_x) != (trans == ilatrans_("N") ? 1 + ( n - 1 )*abs( incx ) : 1 + ( m - 1 )*abs( incx )))
+    rb_raise(rb_eRuntimeError, "shape 0 of x must be %d", trans == ilatrans_("N") ? 1 + ( n - 1 )*abs( incx ) : 1 + ( m - 1 )*abs( incx ));
+  if (NA_TYPE(rblapack_x) != NA_DFLOAT)
+    rblapack_x = na_change_type(rblapack_x, NA_DFLOAT);
+  x = NA_PTR_TYPE(rblapack_x, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = trans == ilatrans_("N") ? 1 + ( m - 1 )*abs( incy ) : 1 + ( n - 1 )*abs( incy );
+    rblapack_y_out__ = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  y_out__ = NA_PTR_TYPE(rblapack_y_out__, doublereal*);
+  MEMCPY(y_out__, y, doublereal, NA_TOTAL(rblapack_y));
+  rblapack_y = rblapack_y_out__;
+  y = y_out__;
+
+  dla_gbamv_(&trans, &m, &n, &kl, &ku, &alpha, ab, &ldab, x, &incx, &beta, y, &incy);
+
+  return rblapack_y;
+}
+
+void
+init_lapack_dla_gbamv(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "dla_gbamv", rblapack_dla_gbamv, -1);
+}