ruby-lapack 1.6 → 1.7

data/ext/slaed8.c

@@ -1,206 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slaed8_(integer* icompq, integer* k, integer* n, integer* qsiz, real* d, real* q, integer* ldq, integer* indxq, real* rho, integer* cutpnt, real* z, real* dlamda, real* q2, integer* ldq2, real* w, integer* perm, integer* givptr, integer* givcol, real* givnum, integer* indxp, integer* indx, integer* info);
-
-
-static VALUE
-rblapack_slaed8(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_icompq;
-  integer icompq; 
-  VALUE rblapack_qsiz;
-  integer qsiz; 
-  VALUE rblapack_d;
-  real *d; 
-  VALUE rblapack_q;
-  real *q; 
-  VALUE rblapack_ldq;
-  integer ldq; 
-  VALUE rblapack_indxq;
-  integer *indxq; 
-  VALUE rblapack_rho;
-  real rho; 
-  VALUE rblapack_cutpnt;
-  integer cutpnt; 
-  VALUE rblapack_z;
-  real *z; 
-  VALUE rblapack_k;
-  integer k; 
-  VALUE rblapack_dlamda;
-  real *dlamda; 
-  VALUE rblapack_q2;
-  real *q2; 
-  VALUE rblapack_w;
-  real *w; 
-  VALUE rblapack_perm;
-  integer *perm; 
-  VALUE rblapack_givptr;
-  integer givptr; 
-  VALUE rblapack_givcol;
-  integer *givcol; 
-  VALUE rblapack_givnum;
-  real *givnum; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack_d_out__;
-  real *d_out__;
-  VALUE rblapack_q_out__;
-  real *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.slaed8( icompq, qsiz, d, q, ldq, indxq, rho, cutpnt, z, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLAED8( 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*  SLAED8 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) REAL 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) REAL 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) REAL\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*         SLAED3.\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) REAL 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) REAL array, dimension (N)\n*         A copy of the first K eigenvalues which will be used by\n*         SLAED3 to form the secular equation.\n*\n*  Q2     (output) REAL 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*         SLAED7 in a matrix multiply (SGEMM) 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) REAL array, dimension (N)\n*         The first k values of the final deflation-altered z-vector and\n*         will be passed to SLAED3.\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) REAL 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.slaed8( 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_SFLOAT)
-    rblapack_d = na_change_type(rblapack_d, NA_SFLOAT);
-  d = NA_PTR_TYPE(rblapack_d, real*);
-  ldq = NUM2INT(rblapack_ldq);
-  rho = (real)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_SFLOAT)
-    rblapack_z = na_change_type(rblapack_z, NA_SFLOAT);
-  z = NA_PTR_TYPE(rblapack_z, real*);
-  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_SFLOAT)
-    rblapack_q = na_change_type(rblapack_q, NA_SFLOAT);
-  q = NA_PTR_TYPE(rblapack_q, real*);
-  cutpnt = NUM2INT(rblapack_cutpnt);
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_dlamda = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  dlamda = NA_PTR_TYPE(rblapack_dlamda, real*);
-  {
-    int shape[2];
-    shape[0] = icompq==0 ? 0 : ldq2;
-    shape[1] = icompq==0 ? 0 : n;
-    rblapack_q2 = na_make_object(NA_SFLOAT, 2, shape, cNArray);
-  }
-  q2 = NA_PTR_TYPE(rblapack_q2, real*);
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_w = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  w = NA_PTR_TYPE(rblapack_w, real*);
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_perm = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  perm = NA_PTR_TYPE(rblapack_perm, integer*);
-  {
-    int 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*);
-  {
-    int shape[2];
-    shape[0] = 2;
-    shape[1] = n;
-    rblapack_givnum = na_make_object(NA_SFLOAT, 2, shape, cNArray);
-  }
-  givnum = NA_PTR_TYPE(rblapack_givnum, real*);
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_d_out__ = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  d_out__ = NA_PTR_TYPE(rblapack_d_out__, real*);
-  MEMCPY(d_out__, d, real, NA_TOTAL(rblapack_d));
-  rblapack_d = rblapack_d_out__;
-  d = d_out__;
-  {
-    int shape[2];
-    shape[0] = icompq==0 ? 0 : ldq;
-    shape[1] = icompq==0 ? 0 : n;
-    rblapack_q_out__ = na_make_object(NA_SFLOAT, 2, shape, cNArray);
-  }
-  q_out__ = NA_PTR_TYPE(rblapack_q_out__, real*);
-  MEMCPY(q_out__, q, real, NA_TOTAL(rblapack_q));
-  rblapack_q = rblapack_q_out__;
-  q = q_out__;
-  indxp = ALLOC_N(integer, (n));
-  indx = ALLOC_N(integer, (n));
-
-  slaed8_(&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_slaed8(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slaed8", rblapack_slaed8, -1);
-}

data/ext/slaed9.c

@@ -1,111 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slaed9_(integer* k, integer* kstart, integer* kstop, integer* n, real* d, real* q, integer* ldq, real* rho, real* dlamda, real* w, real* s, integer* lds, integer* info);
-
-
-static VALUE
-rblapack_slaed9(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_kstart;
-  integer kstart; 
-  VALUE rblapack_kstop;
-  integer kstop; 
-  VALUE rblapack_n;
-  integer n; 
-  VALUE rblapack_rho;
-  real rho; 
-  VALUE rblapack_dlamda;
-  real *dlamda; 
-  VALUE rblapack_w;
-  real *w; 
-  VALUE rblapack_d;
-  real *d; 
-  VALUE rblapack_s;
-  real *s; 
-  VALUE rblapack_info;
-  integer info; 
-  real *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.slaed9( kstart, kstop, n, rho, dlamda, w, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLAED9( K, KSTART, KSTOP, N, D, Q, LDQ, RHO, DLAMDA, W, S, LDS, INFO )\n\n*  Purpose\n*  =======\n*\n*  SLAED9 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 SLAED4 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*          SLAED4.  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) REAL array, dimension (N)\n*          D(I) contains the updated eigenvalues\n*          for KSTART <= I <= KSTOP.\n*\n*  Q       (workspace) REAL 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) REAL\n*          The value of the parameter in the rank one update equation.\n*          RHO >= 0 required.\n*\n*  DLAMDA  (input) REAL 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) REAL 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) REAL 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      REAL               TEMP\n*     ..\n*     .. External Functions ..\n      REAL               SLAMC3, SNRM2\n      EXTERNAL           SLAMC3, SNRM2\n*     ..\n*     .. External Subroutines ..\n      EXTERNAL           SCOPY, SLAED4, 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.slaed9( 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_SFLOAT)
-    rblapack_dlamda = na_change_type(rblapack_dlamda, NA_SFLOAT);
-  dlamda = NA_PTR_TYPE(rblapack_dlamda, real*);
-  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_SFLOAT)
-    rblapack_w = na_change_type(rblapack_w, NA_SFLOAT);
-  w = NA_PTR_TYPE(rblapack_w, real*);
-  rho = (real)NUM2DBL(rblapack_rho);
-  lds = MAX( 1, k );
-  {
-    int shape[1];
-    shape[0] = MAX(1,n);
-    rblapack_d = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  d = NA_PTR_TYPE(rblapack_d, real*);
-  {
-    int shape[2];
-    shape[0] = lds;
-    shape[1] = k;
-    rblapack_s = na_make_object(NA_SFLOAT, 2, shape, cNArray);
-  }
-  s = NA_PTR_TYPE(rblapack_s, real*);
-  q = ALLOC_N(real, (ldq)*(MAX(1,n)));
-
-  slaed9_(&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_slaed9(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slaed9", rblapack_slaed9, -1);
-}

data/ext/slaeda.c

@@ -1,160 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slaeda_(integer* n, integer* tlvls, integer* curlvl, integer* curpbm, integer* prmptr, integer* perm, integer* givptr, integer* givcol, real* givnum, real* q, integer* qptr, real* z, real* ztemp, integer* info);
-
-
-static VALUE
-rblapack_slaeda(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;
-  real *givnum; 
-  VALUE rblapack_q;
-  real *q; 
-  VALUE rblapack_qptr;
-  integer *qptr; 
-  VALUE rblapack_z;
-  real *z; 
-  VALUE rblapack_info;
-  integer info; 
-  real *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.slaeda( tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol, givnum, q, qptr, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLAEDA( N, TLVLS, CURLVL, CURPBM, PRMPTR, PERM, GIVPTR, GIVCOL, GIVNUM, Q, QPTR, Z, ZTEMP, INFO )\n\n*  Purpose\n*  =======\n*\n*  SLAEDA 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) 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*  Q      (input) REAL 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) REAL 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) REAL 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.slaeda( 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_SFLOAT)
-    rblapack_givnum = na_change_type(rblapack_givnum, NA_SFLOAT);
-  givnum = NA_PTR_TYPE(rblapack_givnum, real*);
-  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_SFLOAT)
-    rblapack_q = na_change_type(rblapack_q, NA_SFLOAT);
-  q = NA_PTR_TYPE(rblapack_q, real*);
-  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*);
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_z = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  z = NA_PTR_TYPE(rblapack_z, real*);
-  ztemp = ALLOC_N(real, (n));
-
-  slaeda_(&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_slaeda(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slaeda", rblapack_slaeda, -1);
-}