ruby-lapack 1.7 → 1.7.1

data/ext/dlaed8.c

@@ -0,0 +1,206 @@
+#include "rb_lapack.h"
+
+extern VOID dlaed8_(integer* icompq, integer* k, integer* n, integer* qsiz, doublereal* d, doublereal* q, integer* ldq, integer* indxq, doublereal* rho, integer* cutpnt, doublereal* z, doublereal* dlamda, doublereal* q2, integer* ldq2, doublereal* w, integer* perm, integer* givptr, integer* givcol, doublereal* givnum, integer* indxp, integer* indx, integer* info);
+
+
+static VALUE
+rblapack_dlaed8(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_icompq;
+  integer icompq; 
+  VALUE rblapack_qsiz;
+  integer qsiz; 
+  VALUE rblapack_d;
+  doublereal *d; 
+  VALUE rblapack_q;
+  doublereal *q; 
+  VALUE rblapack_ldq;
+  integer ldq; 
+  VALUE rblapack_indxq;
+  integer *indxq; 
+  VALUE rblapack_rho;
+  doublereal rho; 
+  VALUE rblapack_cutpnt;
+  integer cutpnt; 
+  VALUE rblapack_z;
+  doublereal *z; 
+  VALUE rblapack_k;
+  integer k; 
+  VALUE rblapack_dlamda;
+  doublereal *dlamda; 
+  VALUE rblapack_q2;
+  doublereal *q2; 
+  VALUE rblapack_w;
+  doublereal *w; 
+  VALUE rblapack_perm;
+  integer *perm; 
+  VALUE rblapack_givptr;
+  integer givptr; 
+  VALUE rblapack_givcol;
+  integer *givcol; 
+  VALUE rblapack_givnum;
+  doublereal *givnum; 
+  VALUE rblapack_info;
+  integer info; 
+  VALUE rblapack_d_out__;
+  doublereal *d_out__;
+  VALUE rblapack_q_out__;
+  doublereal *q_out__;
+  integer *indxp;
+  integer *indx;
+
+  integer n;
+  integer ldq2;
+
+  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  k, dlamda, q2, w, perm, givptr, givcol, givnum, info, d, q, rho = NumRu::Lapack.dlaed8( icompq, qsiz, d, q, ldq, indxq, rho, cutpnt, z, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLAED8( ICOMPQ, K, N, QSIZ, D, Q, LDQ, INDXQ, RHO, CUTPNT, Z, DLAMDA, Q2, LDQ2, W, PERM, GIVPTR, GIVCOL, GIVNUM, INDXP, INDX, INFO )\n\n*  Purpose\n*  =======\n*\n*  DLAED8 merges the two sets of eigenvalues together into a single\n*  sorted set.  Then it tries to deflate the size of the problem.\n*  There are two ways in which deflation can occur:  when two or more\n*  eigenvalues are close together or if there is a tiny element in the\n*  Z vector.  For each such occurrence the order of the related secular\n*  equation problem is reduced by one.\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*  K      (output) INTEGER\n*         The number of non-deflated eigenvalues, and the order of the\n*         related secular equation.\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*  D      (input/output) DOUBLE PRECISION array, dimension (N)\n*         On entry, the eigenvalues of the two submatrices to be\n*         combined.  On exit, the trailing (N-K) updated eigenvalues\n*         (those which were deflated) sorted into increasing order.\n*\n*  Q      (input/output) DOUBLE PRECISION array, dimension (LDQ,N)\n*         If ICOMPQ = 0, Q is not referenced.  Otherwise,\n*         on entry, Q contains the eigenvectors of the partially solved\n*         system which has been previously updated in matrix\n*         multiplies with other partially solved eigensystems.\n*         On exit, Q contains the trailing (N-K) updated eigenvectors\n*         (those which were deflated) in its last N-K columns.\n*\n*  LDQ    (input) INTEGER\n*         The leading dimension of the array Q.  LDQ >= max(1,N).\n*\n*  INDXQ  (input) INTEGER array, dimension (N)\n*         The permutation which separately sorts the two sub-problems\n*         in D into ascending order.  Note that elements in the second\n*         half of this permutation must first have CUTPNT added to\n*         their values in order to be accurate.\n*\n*  RHO    (input/output) DOUBLE PRECISION\n*         On entry, the off-diagonal element associated with the rank-1\n*         cut which originally split the two submatrices which are now\n*         being recombined.\n*         On exit, RHO has been modified to the value required by\n*         DLAED3.\n*\n*  CUTPNT (input) INTEGER\n*         The location of the last eigenvalue in the leading\n*         sub-matrix.  min(1,N) <= CUTPNT <= N.\n*\n*  Z      (input) DOUBLE PRECISION array, dimension (N)\n*         On entry, Z contains the updating vector (the last row of\n*         the first sub-eigenvector matrix and the first row of the\n*         second sub-eigenvector matrix).\n*         On exit, the contents of Z are destroyed by the updating\n*         process.\n*\n*  DLAMDA (output) DOUBLE PRECISION array, dimension (N)\n*         A copy of the first K eigenvalues which will be used by\n*         DLAED3 to form the secular equation.\n*\n*  Q2     (output) DOUBLE PRECISION array, dimension (LDQ2,N)\n*         If ICOMPQ = 0, Q2 is not referenced.  Otherwise,\n*         a copy of the first K eigenvectors which will be used by\n*         DLAED7 in a matrix multiply (DGEMM) to update the new\n*         eigenvectors.\n*\n*  LDQ2   (input) INTEGER\n*         The leading dimension of the array Q2.  LDQ2 >= max(1,N).\n*\n*  W      (output) DOUBLE PRECISION array, dimension (N)\n*         The first k values of the final deflation-altered z-vector and\n*         will be passed to DLAED3.\n*\n*  PERM   (output) INTEGER array, dimension (N)\n*         The permutations (from deflation and sorting) to be applied\n*         to each eigenblock.\n*\n*  GIVPTR (output) INTEGER\n*         The number of Givens rotations which took place in this\n*         subproblem.\n*\n*  GIVCOL (output) INTEGER array, dimension (2, N)\n*         Each pair of numbers indicates a pair of columns to take place\n*         in a Givens rotation.\n*\n*  GIVNUM (output) DOUBLE PRECISION array, dimension (2, N)\n*         Each number indicates the S value to be used in the\n*         corresponding Givens rotation.\n*\n*  INDXP  (workspace) INTEGER array, dimension (N)\n*         The permutation used to place deflated values of D at the end\n*         of the array.  INDXP(1:K) points to the nondeflated D-values\n*         and INDXP(K+1:N) points to the deflated eigenvalues.\n*\n*  INDX   (workspace) INTEGER array, dimension (N)\n*         The permutation used to sort the contents of D into ascending\n*         order.\n*\n*  INFO   (output) INTEGER\n*          = 0:  successful exit.\n*          < 0:  if INFO = -i, the i-th argument had an illegal value.\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");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  k, dlamda, q2, w, perm, givptr, givcol, givnum, info, d, q, rho = NumRu::Lapack.dlaed8( icompq, qsiz, d, q, ldq, indxq, rho, cutpnt, z, [: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_icompq = argv[0];
+  rblapack_qsiz = argv[1];
+  rblapack_d = argv[2];
+  rblapack_q = argv[3];
+  rblapack_ldq = argv[4];
+  rblapack_indxq = argv[5];
+  rblapack_rho = argv[6];
+  rblapack_cutpnt = argv[7];
+  rblapack_z = argv[8];
+  if (argc == 9) {
+  } else if (rblapack_options != Qnil) {
+  } else {
+  }
+
+  icompq = NUM2INT(rblapack_icompq);
+  if (!NA_IsNArray(rblapack_d))
+    rb_raise(rb_eArgError, "d (3th argument) must be NArray");
+  if (NA_RANK(rblapack_d) != 1)
+    rb_raise(rb_eArgError, "rank of d (3th argument) must be %d", 1);
+  n = NA_SHAPE0(rblapack_d);
+  if (NA_TYPE(rblapack_d) != NA_DFLOAT)
+    rblapack_d = na_change_type(rblapack_d, NA_DFLOAT);
+  d = NA_PTR_TYPE(rblapack_d, doublereal*);
+  ldq = NUM2INT(rblapack_ldq);
+  rho = NUM2DBL(rblapack_rho);
+  if (!NA_IsNArray(rblapack_z))
+    rb_raise(rb_eArgError, "z (9th argument) must be NArray");
+  if (NA_RANK(rblapack_z) != 1)
+    rb_raise(rb_eArgError, "rank of z (9th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_z) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of z must be the same as shape 0 of d");
+  if (NA_TYPE(rblapack_z) != NA_DFLOAT)
+    rblapack_z = na_change_type(rblapack_z, NA_DFLOAT);
+  z = NA_PTR_TYPE(rblapack_z, doublereal*);
+  qsiz = NUM2INT(rblapack_qsiz);
+  if (!NA_IsNArray(rblapack_indxq))
+    rb_raise(rb_eArgError, "indxq (6th argument) must be NArray");
+  if (NA_RANK(rblapack_indxq) != 1)
+    rb_raise(rb_eArgError, "rank of indxq (6th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_indxq) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of indxq must be the same as shape 0 of d");
+  if (NA_TYPE(rblapack_indxq) != NA_LINT)
+    rblapack_indxq = na_change_type(rblapack_indxq, NA_LINT);
+  indxq = NA_PTR_TYPE(rblapack_indxq, integer*);
+  ldq2 = MAX(1,n);
+  if (!NA_IsNArray(rblapack_q))
+    rb_raise(rb_eArgError, "q (4th argument) must be NArray");
+  if (NA_RANK(rblapack_q) != 2)
+    rb_raise(rb_eArgError, "rank of q (4th argument) must be %d", 2);
+  if (NA_SHAPE0(rblapack_q) != (icompq==0 ? 0 : ldq))
+    rb_raise(rb_eRuntimeError, "shape 0 of q must be %d", icompq==0 ? 0 : ldq);
+  if (NA_SHAPE1(rblapack_q) != (icompq==0 ? 0 : n))
+    rb_raise(rb_eRuntimeError, "shape 1 of q must be %d", icompq==0 ? 0 : n);
+  if (NA_TYPE(rblapack_q) != NA_DFLOAT)
+    rblapack_q = na_change_type(rblapack_q, NA_DFLOAT);
+  q = NA_PTR_TYPE(rblapack_q, doublereal*);
+  cutpnt = NUM2INT(rblapack_cutpnt);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_dlamda = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  dlamda = NA_PTR_TYPE(rblapack_dlamda, doublereal*);
+  {
+    na_shape_t shape[2];
+    shape[0] = icompq==0 ? 0 : ldq2;
+    shape[1] = icompq==0 ? 0 : n;
+    rblapack_q2 = na_make_object(NA_DFLOAT, 2, shape, cNArray);
+  }
+  q2 = NA_PTR_TYPE(rblapack_q2, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_w = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  w = NA_PTR_TYPE(rblapack_w, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_perm = na_make_object(NA_LINT, 1, shape, cNArray);
+  }
+  perm = NA_PTR_TYPE(rblapack_perm, integer*);
+  {
+    na_shape_t shape[2];
+    shape[0] = 2;
+    shape[1] = n;
+    rblapack_givcol = na_make_object(NA_LINT, 2, shape, cNArray);
+  }
+  givcol = NA_PTR_TYPE(rblapack_givcol, integer*);
+  {
+    na_shape_t shape[2];
+    shape[0] = 2;
+    shape[1] = n;
+    rblapack_givnum = na_make_object(NA_DFLOAT, 2, shape, cNArray);
+  }
+  givnum = NA_PTR_TYPE(rblapack_givnum, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_d_out__ = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  d_out__ = NA_PTR_TYPE(rblapack_d_out__, doublereal*);
+  MEMCPY(d_out__, d, doublereal, NA_TOTAL(rblapack_d));
+  rblapack_d = rblapack_d_out__;
+  d = d_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = icompq==0 ? 0 : ldq;
+    shape[1] = icompq==0 ? 0 : n;
+    rblapack_q_out__ = na_make_object(NA_DFLOAT, 2, shape, cNArray);
+  }
+  q_out__ = NA_PTR_TYPE(rblapack_q_out__, doublereal*);
+  MEMCPY(q_out__, q, doublereal, NA_TOTAL(rblapack_q));
+  rblapack_q = rblapack_q_out__;
+  q = q_out__;
+  indxp = ALLOC_N(integer, (n));
+  indx = ALLOC_N(integer, (n));
+
+  dlaed8_(&icompq, &k, &n, &qsiz, d, q, &ldq, indxq, &rho, &cutpnt, z, dlamda, q2, &ldq2, w, perm, &givptr, givcol, givnum, indxp, indx, &info);
+
+  free(indxp);
+  free(indx);
+  rblapack_k = INT2NUM(k);
+  rblapack_givptr = INT2NUM(givptr);
+  rblapack_info = INT2NUM(info);
+  rblapack_rho = rb_float_new((double)rho);
+  return rb_ary_new3(12, rblapack_k, rblapack_dlamda, rblapack_q2, rblapack_w, rblapack_perm, rblapack_givptr, rblapack_givcol, rblapack_givnum, rblapack_info, rblapack_d, rblapack_q, rblapack_rho);
+}
+
+void
+init_lapack_dlaed8(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "dlaed8", rblapack_dlaed8, -1);
+}

data/ext/dlaed9.c

@@ -0,0 +1,111 @@
+#include "rb_lapack.h"
+
+extern VOID dlaed9_(integer* k, integer* kstart, integer* kstop, integer* n, doublereal* d, doublereal* q, integer* ldq, doublereal* rho, doublereal* dlamda, doublereal* w, doublereal* s, integer* lds, integer* info);
+
+
+static VALUE
+rblapack_dlaed9(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_kstart;
+  integer kstart; 
+  VALUE rblapack_kstop;
+  integer kstop; 
+  VALUE rblapack_n;
+  integer n; 
+  VALUE rblapack_rho;
+  doublereal rho; 
+  VALUE rblapack_dlamda;
+  doublereal *dlamda; 
+  VALUE rblapack_w;
+  doublereal *w; 
+  VALUE rblapack_d;
+  doublereal *d; 
+  VALUE rblapack_s;
+  doublereal *s; 
+  VALUE rblapack_info;
+  integer info; 
+  doublereal *q;
+
+  integer k;
+  integer lds;
+  integer ldq;
+
+  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  d, s, info = NumRu::Lapack.dlaed9( kstart, kstop, n, rho, dlamda, w, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLAED9( K, KSTART, KSTOP, N, D, Q, LDQ, RHO, DLAMDA, W, S, LDS, INFO )\n\n*  Purpose\n*  =======\n*\n*  DLAED9 finds the roots of the secular equation, as defined by the\n*  values in D, Z, and RHO, between KSTART and KSTOP.  It makes the\n*  appropriate calls to DLAED4 and then stores the new matrix of\n*  eigenvectors for use in calculating the next level of Z vectors.\n*\n\n*  Arguments\n*  =========\n*\n*  K       (input) INTEGER\n*          The number of terms in the rational function to be solved by\n*          DLAED4.  K >= 0.\n*\n*  KSTART  (input) INTEGER\n*  KSTOP   (input) INTEGER\n*          The updated eigenvalues Lambda(I), KSTART <= I <= KSTOP\n*          are to be computed.  1 <= KSTART <= KSTOP <= K.\n*\n*  N       (input) INTEGER\n*          The number of rows and columns in the Q matrix.\n*          N >= K (delation may result in N > K).\n*\n*  D       (output) DOUBLE PRECISION array, dimension (N)\n*          D(I) contains the updated eigenvalues\n*          for KSTART <= I <= KSTOP.\n*\n*  Q       (workspace) DOUBLE PRECISION array, dimension (LDQ,N)\n*\n*  LDQ     (input) INTEGER\n*          The leading dimension of the array Q.  LDQ >= max( 1, N ).\n*\n*  RHO     (input) DOUBLE PRECISION\n*          The value of the parameter in the rank one update equation.\n*          RHO >= 0 required.\n*\n*  DLAMDA  (input) DOUBLE PRECISION array, dimension (K)\n*          The first K elements of this array contain the old roots\n*          of the deflated updating problem.  These are the poles\n*          of the secular equation.\n*\n*  W       (input) DOUBLE PRECISION array, dimension (K)\n*          The first K elements of this array contain the components\n*          of the deflation-adjusted updating vector.\n*\n*  S       (output) DOUBLE PRECISION array, dimension (LDS, K)\n*          Will contain the eigenvectors of the repaired matrix which\n*          will be stored for subsequent Z vector calculation and\n*          multiplied by the previously accumulated eigenvectors\n*          to update the system.\n*\n*  LDS     (input) INTEGER\n*          The leading dimension of S.  LDS >= max( 1, K ).\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*     .. Local Scalars ..\n      INTEGER            I, J\n      DOUBLE PRECISION   TEMP\n*     ..\n*     .. External Functions ..\n      DOUBLE PRECISION   DLAMC3, DNRM2\n      EXTERNAL           DLAMC3, DNRM2\n*     ..\n*     .. External Subroutines ..\n      EXTERNAL           DCOPY, DLAED4, XERBLA\n*     ..\n*     .. Intrinsic Functions ..\n      INTRINSIC          MAX, SIGN, SQRT\n*     ..\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  d, s, info = NumRu::Lapack.dlaed9( kstart, kstop, n, rho, dlamda, w, [:usage => usage, :help => help])\n");
+      return Qnil;
+    } 
+  } else
+    rblapack_options = Qnil;
+  if (argc != 6 && argc != 6)
+    rb_raise(rb_eArgError,"wrong number of arguments (%d for 6)", argc);
+  rblapack_kstart = argv[0];
+  rblapack_kstop = argv[1];
+  rblapack_n = argv[2];
+  rblapack_rho = argv[3];
+  rblapack_dlamda = argv[4];
+  rblapack_w = argv[5];
+  if (argc == 6) {
+  } else if (rblapack_options != Qnil) {
+  } else {
+  }
+
+  kstart = NUM2INT(rblapack_kstart);
+  n = NUM2INT(rblapack_n);
+  if (!NA_IsNArray(rblapack_dlamda))
+    rb_raise(rb_eArgError, "dlamda (5th argument) must be NArray");
+  if (NA_RANK(rblapack_dlamda) != 1)
+    rb_raise(rb_eArgError, "rank of dlamda (5th argument) must be %d", 1);
+  k = NA_SHAPE0(rblapack_dlamda);
+  if (NA_TYPE(rblapack_dlamda) != NA_DFLOAT)
+    rblapack_dlamda = na_change_type(rblapack_dlamda, NA_DFLOAT);
+  dlamda = NA_PTR_TYPE(rblapack_dlamda, doublereal*);
+  ldq = MAX( 1, n );
+  kstop = NUM2INT(rblapack_kstop);
+  if (!NA_IsNArray(rblapack_w))
+    rb_raise(rb_eArgError, "w (6th argument) must be NArray");
+  if (NA_RANK(rblapack_w) != 1)
+    rb_raise(rb_eArgError, "rank of w (6th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_w) != k)
+    rb_raise(rb_eRuntimeError, "shape 0 of w must be the same as shape 0 of dlamda");
+  if (NA_TYPE(rblapack_w) != NA_DFLOAT)
+    rblapack_w = na_change_type(rblapack_w, NA_DFLOAT);
+  w = NA_PTR_TYPE(rblapack_w, doublereal*);
+  rho = NUM2DBL(rblapack_rho);
+  lds = MAX( 1, k );
+  {
+    na_shape_t shape[1];
+    shape[0] = MAX(1,n);
+    rblapack_d = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  d = NA_PTR_TYPE(rblapack_d, doublereal*);
+  {
+    na_shape_t shape[2];
+    shape[0] = lds;
+    shape[1] = k;
+    rblapack_s = na_make_object(NA_DFLOAT, 2, shape, cNArray);
+  }
+  s = NA_PTR_TYPE(rblapack_s, doublereal*);
+  q = ALLOC_N(doublereal, (ldq)*(MAX(1,n)));
+
+  dlaed9_(&k, &kstart, &kstop, &n, d, q, &ldq, &rho, dlamda, w, s, &lds, &info);
+
+  free(q);
+  rblapack_info = INT2NUM(info);
+  return rb_ary_new3(3, rblapack_d, rblapack_s, rblapack_info);
+}
+
+void
+init_lapack_dlaed9(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "dlaed9", rblapack_dlaed9, -1);
+}

data/ext/dlaeda.c

@@ -0,0 +1,160 @@
+#include "rb_lapack.h"
+
+extern VOID dlaeda_(integer* n, integer* tlvls, integer* curlvl, integer* curpbm, integer* prmptr, integer* perm, integer* givptr, integer* givcol, doublereal* givnum, doublereal* q, integer* qptr, doublereal* z, doublereal* ztemp, integer* info);
+
+
+static VALUE
+rblapack_dlaeda(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_tlvls;
+  integer tlvls; 
+  VALUE rblapack_curlvl;
+  integer curlvl; 
+  VALUE rblapack_curpbm;
+  integer curpbm; 
+  VALUE rblapack_prmptr;
+  integer *prmptr; 
+  VALUE rblapack_perm;
+  integer *perm; 
+  VALUE rblapack_givptr;
+  integer *givptr; 
+  VALUE rblapack_givcol;
+  integer *givcol; 
+  VALUE rblapack_givnum;
+  doublereal *givnum; 
+  VALUE rblapack_q;
+  doublereal *q; 
+  VALUE rblapack_qptr;
+  integer *qptr; 
+  VALUE rblapack_z;
+  doublereal *z; 
+  VALUE rblapack_info;
+  integer info; 
+  doublereal *ztemp;
+
+  integer ldqptr;
+  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  z, info = NumRu::Lapack.dlaeda( tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol, givnum, q, qptr, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLAEDA( N, TLVLS, CURLVL, CURPBM, PRMPTR, PERM, GIVPTR, GIVCOL, GIVNUM, Q, QPTR, Z, ZTEMP, INFO )\n\n*  Purpose\n*  =======\n*\n*  DLAEDA computes the Z vector corresponding to the merge step in the\n*  CURLVLth step of the merge process with TLVLS steps for the CURPBMth\n*  problem.\n*\n\n*  Arguments\n*  =========\n*\n*  N      (input) INTEGER\n*         The dimension of the symmetric tridiagonal matrix.  N >= 0.\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*  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 incidentally the\n*         size of 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*  Q      (input) DOUBLE PRECISION array, dimension (N**2)\n*         Contains the square eigenblocks from previous levels, the\n*         starting positions for blocks are given by QPTR.\n*\n*  QPTR   (input) INTEGER array, dimension (N+2)\n*         Contains a list of pointers which indicate where in Q an\n*         eigenblock is stored.  SQRT( QPTR(i+1) - QPTR(i) ) indicates\n*         the size of the block.\n*\n*  Z      (output) DOUBLE PRECISION array, dimension (N)\n*         On output this vector contains the updating vector (the last\n*         row of the first sub-eigenvector matrix and the first row of\n*         the second sub-eigenvector matrix).\n*\n*  ZTEMP  (workspace) DOUBLE PRECISION array, dimension (N)\n*\n*  INFO   (output) INTEGER\n*          = 0:  successful exit.\n*          < 0:  if INFO = -i, the i-th argument had an illegal value.\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");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  z, info = NumRu::Lapack.dlaeda( tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol, givnum, q, qptr, [:usage => usage, :help => help])\n");
+      return Qnil;
+    } 
+  } else
+    rblapack_options = Qnil;
+  if (argc != 10 && argc != 10)
+    rb_raise(rb_eArgError,"wrong number of arguments (%d for 10)", argc);
+  rblapack_tlvls = argv[0];
+  rblapack_curlvl = argv[1];
+  rblapack_curpbm = argv[2];
+  rblapack_prmptr = argv[3];
+  rblapack_perm = argv[4];
+  rblapack_givptr = argv[5];
+  rblapack_givcol = argv[6];
+  rblapack_givnum = argv[7];
+  rblapack_q = argv[8];
+  rblapack_qptr = argv[9];
+  if (argc == 10) {
+  } else if (rblapack_options != Qnil) {
+  } else {
+  }
+
+  tlvls = NUM2INT(rblapack_tlvls);
+  curpbm = NUM2INT(rblapack_curpbm);
+  if (!NA_IsNArray(rblapack_qptr))
+    rb_raise(rb_eArgError, "qptr (10th argument) must be NArray");
+  if (NA_RANK(rblapack_qptr) != 1)
+    rb_raise(rb_eArgError, "rank of qptr (10th argument) must be %d", 1);
+  ldqptr = NA_SHAPE0(rblapack_qptr);
+  if (NA_TYPE(rblapack_qptr) != NA_LINT)
+    rblapack_qptr = na_change_type(rblapack_qptr, NA_LINT);
+  qptr = NA_PTR_TYPE(rblapack_qptr, integer*);
+  curlvl = NUM2INT(rblapack_curlvl);
+  n = ldqptr-2;
+  if (!NA_IsNArray(rblapack_prmptr))
+    rb_raise(rb_eArgError, "prmptr (4th argument) must be NArray");
+  if (NA_RANK(rblapack_prmptr) != 1)
+    rb_raise(rb_eArgError, "rank of prmptr (4th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_prmptr) != (n*LG(n)))
+    rb_raise(rb_eRuntimeError, "shape 0 of prmptr must be %d", n*LG(n));
+  if (NA_TYPE(rblapack_prmptr) != NA_LINT)
+    rblapack_prmptr = na_change_type(rblapack_prmptr, NA_LINT);
+  prmptr = NA_PTR_TYPE(rblapack_prmptr, integer*);
+  if (!NA_IsNArray(rblapack_givptr))
+    rb_raise(rb_eArgError, "givptr (6th argument) must be NArray");
+  if (NA_RANK(rblapack_givptr) != 1)
+    rb_raise(rb_eArgError, "rank of givptr (6th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_givptr) != (n*LG(n)))
+    rb_raise(rb_eRuntimeError, "shape 0 of givptr must be %d", n*LG(n));
+  if (NA_TYPE(rblapack_givptr) != NA_LINT)
+    rblapack_givptr = na_change_type(rblapack_givptr, NA_LINT);
+  givptr = NA_PTR_TYPE(rblapack_givptr, integer*);
+  if (!NA_IsNArray(rblapack_givnum))
+    rb_raise(rb_eArgError, "givnum (8th argument) must be NArray");
+  if (NA_RANK(rblapack_givnum) != 2)
+    rb_raise(rb_eArgError, "rank of givnum (8th argument) must be %d", 2);
+  if (NA_SHAPE0(rblapack_givnum) != (2))
+    rb_raise(rb_eRuntimeError, "shape 0 of givnum must be %d", 2);
+  if (NA_SHAPE1(rblapack_givnum) != (n*LG(n)))
+    rb_raise(rb_eRuntimeError, "shape 1 of givnum must be %d", n*LG(n));
+  if (NA_TYPE(rblapack_givnum) != NA_DFLOAT)
+    rblapack_givnum = na_change_type(rblapack_givnum, NA_DFLOAT);
+  givnum = NA_PTR_TYPE(rblapack_givnum, doublereal*);
+  if (!NA_IsNArray(rblapack_perm))
+    rb_raise(rb_eArgError, "perm (5th argument) must be NArray");
+  if (NA_RANK(rblapack_perm) != 1)
+    rb_raise(rb_eArgError, "rank of perm (5th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_perm) != (n*LG(n)))
+    rb_raise(rb_eRuntimeError, "shape 0 of perm must be %d", n*LG(n));
+  if (NA_TYPE(rblapack_perm) != NA_LINT)
+    rblapack_perm = na_change_type(rblapack_perm, NA_LINT);
+  perm = NA_PTR_TYPE(rblapack_perm, integer*);
+  if (!NA_IsNArray(rblapack_q))
+    rb_raise(rb_eArgError, "q (9th argument) must be NArray");
+  if (NA_RANK(rblapack_q) != 1)
+    rb_raise(rb_eArgError, "rank of q (9th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_q) != (pow(n,2)))
+    rb_raise(rb_eRuntimeError, "shape 0 of q must be %d", pow(n,2));
+  if (NA_TYPE(rblapack_q) != NA_DFLOAT)
+    rblapack_q = na_change_type(rblapack_q, NA_DFLOAT);
+  q = NA_PTR_TYPE(rblapack_q, doublereal*);
+  if (!NA_IsNArray(rblapack_givcol))
+    rb_raise(rb_eArgError, "givcol (7th argument) must be NArray");
+  if (NA_RANK(rblapack_givcol) != 2)
+    rb_raise(rb_eArgError, "rank of givcol (7th argument) must be %d", 2);
+  if (NA_SHAPE0(rblapack_givcol) != (2))
+    rb_raise(rb_eRuntimeError, "shape 0 of givcol must be %d", 2);
+  if (NA_SHAPE1(rblapack_givcol) != (n*LG(n)))
+    rb_raise(rb_eRuntimeError, "shape 1 of givcol must be %d", n*LG(n));
+  if (NA_TYPE(rblapack_givcol) != NA_LINT)
+    rblapack_givcol = na_change_type(rblapack_givcol, NA_LINT);
+  givcol = NA_PTR_TYPE(rblapack_givcol, integer*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_z = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  z = NA_PTR_TYPE(rblapack_z, doublereal*);
+  ztemp = ALLOC_N(doublereal, (n));
+
+  dlaeda_(&n, &tlvls, &curlvl, &curpbm, prmptr, perm, givptr, givcol, givnum, q, qptr, z, ztemp, &info);
+
+  free(ztemp);
+  rblapack_info = INT2NUM(info);
+  return rb_ary_new3(2, rblapack_z, rblapack_info);
+}
+
+void
+init_lapack_dlaeda(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "dlaeda", rblapack_dlaeda, -1);
+}