ruby-lapack 1.6 → 1.7

data/ext/dlaed0.c

@@ -1,127 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID dlaed0_(integer* icompq, integer* qsiz, integer* n, doublereal* d, doublereal* e, doublereal* q, integer* ldq, doublereal* qstore, integer* ldqs, doublereal* work, integer* iwork, integer* info);
-
-
-static VALUE
-rblapack_dlaed0(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_icompq;
-  integer icompq; 
-  VALUE rblapack_qsiz;
-  integer qsiz; 
-  VALUE rblapack_d;
-  doublereal *d; 
-  VALUE rblapack_e;
-  doublereal *e; 
-  VALUE rblapack_q;
-  doublereal *q; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack_d_out__;
-  doublereal *d_out__;
-  VALUE rblapack_q_out__;
-  doublereal *q_out__;
-  doublereal *qstore;
-  doublereal *work;
-  integer *iwork;
-
-  integer n;
-  integer ldq;
-  integer ldqs;
-
-  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  info, d, q = NumRu::Lapack.dlaed0( icompq, qsiz, d, e, q, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLAED0( ICOMPQ, QSIZ, N, D, E, Q, LDQ, QSTORE, LDQS, WORK, IWORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  DLAED0 computes all eigenvalues and corresponding eigenvectors of a\n*  symmetric tridiagonal matrix using the divide and conquer method.\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*          = 2:  Compute eigenvalues and eigenvectors of tridiagonal\n*                matrix.\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*  N      (input) INTEGER\n*         The dimension of the symmetric tridiagonal matrix.  N >= 0.\n*\n*  D      (input/output) DOUBLE PRECISION array, dimension (N)\n*         On entry, the main diagonal of the tridiagonal matrix.\n*         On exit, its eigenvalues.\n*\n*  E      (input) DOUBLE PRECISION array, dimension (N-1)\n*         The off-diagonal elements of the tridiagonal matrix.\n*         On exit, E has been destroyed.\n*\n*  Q      (input/output) DOUBLE PRECISION array, dimension (LDQ, N)\n*         On entry, Q must contain an N-by-N orthogonal matrix.\n*         If ICOMPQ = 0    Q is not referenced.\n*         If ICOMPQ = 1    On entry, Q is a subset of the columns of the\n*                          orthogonal matrix used to reduce the full\n*                          matrix to tridiagonal form corresponding to\n*                          the subset of the full matrix which is being\n*                          decomposed at this time.\n*         If ICOMPQ = 2    On entry, Q will be the identity matrix.\n*                          On exit, Q contains the eigenvectors of the\n*                          tridiagonal matrix.\n*\n*  LDQ    (input) INTEGER\n*         The leading dimension of the array Q.  If eigenvectors are\n*         desired, then  LDQ >= max(1,N).  In any case,  LDQ >= 1.\n*\n*  QSTORE (workspace) DOUBLE PRECISION array, dimension (LDQS, N)\n*         Referenced only when ICOMPQ = 1.  Used to store parts of\n*         the eigenvector matrix when the updating matrix multiplies\n*         take place.\n*\n*  LDQS   (input) INTEGER\n*         The leading dimension of the array QSTORE.  If ICOMPQ = 1,\n*         then  LDQS >= max(1,N).  In any case,  LDQS >= 1.\n*\n*  WORK   (workspace) DOUBLE PRECISION array,\n*         If ICOMPQ = 0 or 1, the dimension of WORK must be at least\n*                     1 + 3*N + 2*N*lg N + 2*N**2\n*                     ( lg( N ) = smallest integer k\n*                                 such that 2^k >= N )\n*         If ICOMPQ = 2, the dimension of WORK must be at least\n*                     4*N + N**2.\n*\n*  IWORK  (workspace) INTEGER array,\n*         If ICOMPQ = 0 or 1, the dimension of IWORK must be at least\n*                        6 + 6*N + 5*N*lg N.\n*                        ( lg( N ) = smallest integer k\n*                                    such that 2^k >= N )\n*         If ICOMPQ = 2, the dimension of IWORK must be at least\n*                        3 + 5*N.\n*\n*  INFO   (output) INTEGER\n*          = 0:  successful exit.\n*          < 0:  if INFO = -i, the i-th argument had an illegal value.\n*          > 0:  The algorithm failed to compute an eigenvalue while\n*                working on the submatrix lying in rows and columns\n*                INFO/(N+1) through mod(INFO,N+1).\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  info, d, q = NumRu::Lapack.dlaed0( icompq, qsiz, d, e, q, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 5 && argc != 5)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 5)", argc);
-  rblapack_icompq = argv[0];
-  rblapack_qsiz = argv[1];
-  rblapack_d = argv[2];
-  rblapack_e = argv[3];
-  rblapack_q = argv[4];
-  if (argc == 5) {
-  } 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*);
-  if (!NA_IsNArray(rblapack_q))
-    rb_raise(rb_eArgError, "q (5th argument) must be NArray");
-  if (NA_RANK(rblapack_q) != 2)
-    rb_raise(rb_eArgError, "rank of q (5th argument) must be %d", 2);
-  ldq = NA_SHAPE0(rblapack_q);
-  if (NA_SHAPE1(rblapack_q) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of q must be the same as shape 0 of d");
-  if (NA_TYPE(rblapack_q) != NA_DFLOAT)
-    rblapack_q = na_change_type(rblapack_q, NA_DFLOAT);
-  q = NA_PTR_TYPE(rblapack_q, doublereal*);
-  qsiz = NUM2INT(rblapack_qsiz);
-  ldqs = icompq == 1 ? MAX(1,n) : 1;
-  if (!NA_IsNArray(rblapack_e))
-    rb_raise(rb_eArgError, "e (4th argument) must be NArray");
-  if (NA_RANK(rblapack_e) != 1)
-    rb_raise(rb_eArgError, "rank of e (4th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_e) != (n-1))
-    rb_raise(rb_eRuntimeError, "shape 0 of e must be %d", n-1);
-  if (NA_TYPE(rblapack_e) != NA_DFLOAT)
-    rblapack_e = na_change_type(rblapack_e, NA_DFLOAT);
-  e = NA_PTR_TYPE(rblapack_e, doublereal*);
-  {
-    int 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__;
-  {
-    int shape[2];
-    shape[0] = ldq;
-    shape[1] = 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__;
-  qstore = ALLOC_N(doublereal, (ldqs)*(n));
-  work = ALLOC_N(doublereal, (((icompq == 0) || (icompq == 1)) ? 1 + 3*n + 2*n*LG(n) + 2*pow(n,2) : icompq == 2 ? 4*n + pow(n,2) : 0));
-  iwork = ALLOC_N(integer, (((icompq == 0) || (icompq == 1)) ? 6 + 6*n + 5*n*LG(n) : icompq == 2 ? 3 + 5*n : 0));
-
-  dlaed0_(&icompq, &qsiz, &n, d, e, q, &ldq, qstore, &ldqs, work, iwork, &info);
-
-  free(qstore);
-  free(work);
-  free(iwork);
-  rblapack_info = INT2NUM(info);
-  return rb_ary_new3(3, rblapack_info, rblapack_d, rblapack_q);
-}
-
-void
-init_lapack_dlaed0(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "dlaed0", rblapack_dlaed0, -1);
-}

data/ext/dlaed1.c

@@ -1,133 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID dlaed1_(integer* n, doublereal* d, doublereal* q, integer* ldq, integer* indxq, doublereal* rho, integer* cutpnt, doublereal* work, integer* iwork, integer* info);
-
-
-static VALUE
-rblapack_dlaed1(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_d;
-  doublereal *d; 
-  VALUE rblapack_q;
-  doublereal *q; 
-  VALUE rblapack_indxq;
-  integer *indxq; 
-  VALUE rblapack_rho;
-  doublereal rho; 
-  VALUE rblapack_cutpnt;
-  integer cutpnt; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack_d_out__;
-  doublereal *d_out__;
-  VALUE rblapack_q_out__;
-  doublereal *q_out__;
-  VALUE rblapack_indxq_out__;
-  integer *indxq_out__;
-  doublereal *work;
-  integer *iwork;
-
-  integer n;
-  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  info, d, q, indxq = NumRu::Lapack.dlaed1( d, q, indxq, rho, cutpnt, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLAED1( N, D, Q, LDQ, INDXQ, RHO, CUTPNT, WORK, IWORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  DLAED1 computes the updated eigensystem of a diagonal\n*  matrix after modification by a rank-one symmetric matrix.  This\n*  routine is used only for the eigenproblem which requires all\n*  eigenvalues and eigenvectors of a tridiagonal matrix.  DLAED7 handles\n*  the case in which eigenvalues only or eigenvalues and eigenvectors\n*  of a full symmetric matrix (which was reduced to tridiagonal form)\n*  are desired.\n*\n*    T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out)\n*\n*     where Z = Q'u, u is a vector of length N with ones in the\n*     CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.\n*\n*     The eigenvectors of the original matrix are stored in Q, and the\n*     eigenvalues are in D.  The algorithm consists of three stages:\n*\n*        The first stage consists of deflating the size of the problem\n*        when there are multiple eigenvalues or if there is a zero in\n*        the Z vector.  For each such occurence the dimension of the\n*        secular equation problem is reduced by one.  This stage is\n*        performed by the routine DLAED2.\n*\n*        The second stage consists of calculating the updated\n*        eigenvalues. This is done by finding the roots of the secular\n*        equation via the routine DLAED4 (as called by DLAED3).\n*        This routine also calculates the eigenvectors of the current\n*        problem.\n*\n*        The final stage consists of computing the updated eigenvectors\n*        directly using the updated eigenvalues.  The eigenvectors for\n*        the current problem are multiplied with the eigenvectors from\n*        the overall problem.\n*\n\n*  Arguments\n*  =========\n*\n*  N      (input) INTEGER\n*         The dimension of the symmetric tridiagonal matrix.  N >= 0.\n*\n*  D      (input/output) DOUBLE PRECISION array, dimension (N)\n*         On entry, the eigenvalues of the rank-1-perturbed matrix.\n*         On exit, the eigenvalues of the repaired matrix.\n*\n*  Q      (input/output) DOUBLE PRECISION array, dimension (LDQ,N)\n*         On entry, the eigenvectors of the rank-1-perturbed matrix.\n*         On exit, the eigenvectors of the repaired tridiagonal matrix.\n*\n*  LDQ    (input) INTEGER\n*         The leading dimension of the array Q.  LDQ >= max(1,N).\n*\n*  INDXQ  (input/output) INTEGER array, dimension (N)\n*         On entry, the permutation which separately sorts the two\n*         subproblems in D into ascending order.\n*         On exit, the permutation which will reintegrate the\n*         subproblems back into sorted order,\n*         i.e. D( INDXQ( I = 1, N ) ) will be in ascending order.\n*\n*  RHO    (input) DOUBLE PRECISION\n*         The subdiagonal entry used to create the rank-1 modification.\n*\n*  CUTPNT (input) INTEGER\n*         The location of the last eigenvalue in the leading sub-matrix.\n*         min(1,N) <= CUTPNT <= N/2.\n*\n*  WORK   (workspace) DOUBLE PRECISION array, dimension (4*N + N**2)\n*\n*  IWORK  (workspace) INTEGER array, dimension (4*N)\n*\n*  INFO   (output) INTEGER\n*          = 0:  successful exit.\n*          < 0:  if INFO = -i, the i-th argument had an illegal value.\n*          > 0:  if INFO = 1, an eigenvalue did not converge\n*\n\n*  Further Details\n*  ===============\n*\n*  Based on contributions by\n*     Jeff Rutter, Computer Science Division, University of California\n*     at Berkeley, USA\n*  Modified by Francoise Tisseur, University of Tennessee.\n*\n*  =====================================================================\n*\n*     .. Local Scalars ..\n      INTEGER            COLTYP, I, IDLMDA, INDX, INDXC, INDXP, IQ2, IS,\n     $                   IW, IZ, K, N1, N2, ZPP1\n*     ..\n*     .. External Subroutines ..\n      EXTERNAL           DCOPY, DLAED2, DLAED3, DLAMRG, XERBLA\n*     ..\n*     .. Intrinsic Functions ..\n      INTRINSIC          MAX, MIN\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  info, d, q, indxq = NumRu::Lapack.dlaed1( d, q, indxq, rho, cutpnt, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 5 && argc != 5)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 5)", argc);
-  rblapack_d = argv[0];
-  rblapack_q = argv[1];
-  rblapack_indxq = argv[2];
-  rblapack_rho = argv[3];
-  rblapack_cutpnt = argv[4];
-  if (argc == 5) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  if (!NA_IsNArray(rblapack_d))
-    rb_raise(rb_eArgError, "d (1th argument) must be NArray");
-  if (NA_RANK(rblapack_d) != 1)
-    rb_raise(rb_eArgError, "rank of d (1th 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*);
-  if (!NA_IsNArray(rblapack_indxq))
-    rb_raise(rb_eArgError, "indxq (3th argument) must be NArray");
-  if (NA_RANK(rblapack_indxq) != 1)
-    rb_raise(rb_eArgError, "rank of indxq (3th 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*);
-  cutpnt = NUM2INT(rblapack_cutpnt);
-  if (!NA_IsNArray(rblapack_q))
-    rb_raise(rb_eArgError, "q (2th argument) must be NArray");
-  if (NA_RANK(rblapack_q) != 2)
-    rb_raise(rb_eArgError, "rank of q (2th argument) must be %d", 2);
-  ldq = NA_SHAPE0(rblapack_q);
-  if (NA_SHAPE1(rblapack_q) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of q must be the same as shape 0 of d");
-  if (NA_TYPE(rblapack_q) != NA_DFLOAT)
-    rblapack_q = na_change_type(rblapack_q, NA_DFLOAT);
-  q = NA_PTR_TYPE(rblapack_q, doublereal*);
-  rho = NUM2DBL(rblapack_rho);
-  {
-    int 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__;
-  {
-    int shape[2];
-    shape[0] = ldq;
-    shape[1] = 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__;
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_indxq_out__ = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  indxq_out__ = NA_PTR_TYPE(rblapack_indxq_out__, integer*);
-  MEMCPY(indxq_out__, indxq, integer, NA_TOTAL(rblapack_indxq));
-  rblapack_indxq = rblapack_indxq_out__;
-  indxq = indxq_out__;
-  work = ALLOC_N(doublereal, (4*n + pow(n,2)));
-  iwork = ALLOC_N(integer, (4*n));
-
-  dlaed1_(&n, d, q, &ldq, indxq, &rho, &cutpnt, work, iwork, &info);
-
-  free(work);
-  free(iwork);
-  rblapack_info = INT2NUM(info);
-  return rb_ary_new3(4, rblapack_info, rblapack_d, rblapack_q, rblapack_indxq);
-}
-
-void
-init_lapack_dlaed1(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "dlaed1", rblapack_dlaed1, -1);
-}

data/ext/dlaed2.c

@@ -1,189 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID dlaed2_(integer* k, integer* n, integer* n1, doublereal* d, doublereal* q, integer* ldq, integer* indxq, doublereal* rho, doublereal* z, doublereal* dlamda, doublereal* w, doublereal* q2, integer* indx, integer* indxc, integer* indxp, integer* coltyp, integer* info);
-
-
-static VALUE
-rblapack_dlaed2(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_n1;
-  integer n1; 
-  VALUE rblapack_d;
-  doublereal *d; 
-  VALUE rblapack_q;
-  doublereal *q; 
-  VALUE rblapack_indxq;
-  integer *indxq; 
-  VALUE rblapack_rho;
-  doublereal rho; 
-  VALUE rblapack_z;
-  doublereal *z; 
-  VALUE rblapack_k;
-  integer k; 
-  VALUE rblapack_dlamda;
-  doublereal *dlamda; 
-  VALUE rblapack_w;
-  doublereal *w; 
-  VALUE rblapack_q2;
-  doublereal *q2; 
-  VALUE rblapack_indxc;
-  integer *indxc; 
-  VALUE rblapack_coltyp;
-  integer *coltyp; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack_d_out__;
-  doublereal *d_out__;
-  VALUE rblapack_q_out__;
-  doublereal *q_out__;
-  VALUE rblapack_indxq_out__;
-  integer *indxq_out__;
-  integer *indx;
-  integer *indxp;
-
-  integer n;
-  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  k, dlamda, w, q2, indxc, coltyp, info, d, q, indxq, rho = NumRu::Lapack.dlaed2( n1, d, q, indxq, rho, z, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLAED2( K, N, N1, D, Q, LDQ, INDXQ, RHO, Z, DLAMDA, W, Q2, INDX, INDXC, INDXP, COLTYP, INFO )\n\n*  Purpose\n*  =======\n*\n*  DLAED2 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 entry 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*  K      (output) INTEGER\n*         The number of non-deflated eigenvalues, and the order of the\n*         related secular equation. 0 <= K <=N.\n*\n*  N      (input) INTEGER\n*         The dimension of the symmetric tridiagonal matrix.  N >= 0.\n*\n*  N1     (input) INTEGER\n*         The location of the last eigenvalue in the leading sub-matrix.\n*         min(1,N) <= N1 <= N/2.\n*\n*  D      (input/output) DOUBLE PRECISION array, dimension (N)\n*         On entry, D contains the eigenvalues of the two submatrices to\n*         be combined.\n*         On exit, D contains 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*         On entry, Q contains the eigenvectors of two submatrices in\n*         the two square blocks with corners at (1,1), (N1,N1)\n*         and (N1+1, N1+1), (N,N).\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/output) 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 N1 added to their\n*         values. Destroyed on exit.\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*  Z      (input) DOUBLE PRECISION array, dimension (N)\n*         On entry, Z 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*         On exit, the contents of Z have been 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*  W      (output) DOUBLE PRECISION array, dimension (N)\n*         The first k values of the final deflation-altered z-vector\n*         which will be passed to DLAED3.\n*\n*  Q2     (output) DOUBLE PRECISION array, dimension (N1**2+(N-N1)**2)\n*         A copy of the first K eigenvectors which will be used by\n*         DLAED3 in a matrix multiply (DGEMM) to solve for the new\n*         eigenvectors.\n*\n*  INDX   (workspace) INTEGER array, dimension (N)\n*         The permutation used to sort the contents of DLAMDA into\n*         ascending order.\n*\n*  INDXC  (output) INTEGER array, dimension (N)\n*         The permutation used to arrange the columns of the deflated\n*         Q matrix into three groups:  the first group contains non-zero\n*         elements only at and above N1, the second contains\n*         non-zero elements only below N1, and the third is dense.\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*  COLTYP (workspace/output) INTEGER array, dimension (N)\n*         During execution, a label which will indicate which of the\n*         following types a column in the Q2 matrix is:\n*         1 : non-zero in the upper half only;\n*         2 : dense;\n*         3 : non-zero in the lower half only;\n*         4 : deflated.\n*         On exit, COLTYP(i) is the number of columns of type i,\n*         for i=1 to 4 only.\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*  Modified by Francoise Tisseur, University of Tennessee.\n*\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  k, dlamda, w, q2, indxc, coltyp, info, d, q, indxq, rho = NumRu::Lapack.dlaed2( n1, d, q, indxq, rho, z, [: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_n1 = argv[0];
-  rblapack_d = argv[1];
-  rblapack_q = argv[2];
-  rblapack_indxq = argv[3];
-  rblapack_rho = argv[4];
-  rblapack_z = argv[5];
-  if (argc == 6) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  n1 = NUM2INT(rblapack_n1);
-  if (!NA_IsNArray(rblapack_q))
-    rb_raise(rb_eArgError, "q (3th argument) must be NArray");
-  if (NA_RANK(rblapack_q) != 2)
-    rb_raise(rb_eArgError, "rank of q (3th argument) must be %d", 2);
-  ldq = NA_SHAPE0(rblapack_q);
-  n = NA_SHAPE1(rblapack_q);
-  if (NA_TYPE(rblapack_q) != NA_DFLOAT)
-    rblapack_q = na_change_type(rblapack_q, NA_DFLOAT);
-  q = NA_PTR_TYPE(rblapack_q, doublereal*);
-  rho = NUM2DBL(rblapack_rho);
-  if (!NA_IsNArray(rblapack_d))
-    rb_raise(rb_eArgError, "d (2th argument) must be NArray");
-  if (NA_RANK(rblapack_d) != 1)
-    rb_raise(rb_eArgError, "rank of d (2th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_d) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of d must be the same as shape 1 of q");
-  if (NA_TYPE(rblapack_d) != NA_DFLOAT)
-    rblapack_d = na_change_type(rblapack_d, NA_DFLOAT);
-  d = NA_PTR_TYPE(rblapack_d, doublereal*);
-  if (!NA_IsNArray(rblapack_z))
-    rb_raise(rb_eArgError, "z (6th argument) must be NArray");
-  if (NA_RANK(rblapack_z) != 1)
-    rb_raise(rb_eArgError, "rank of z (6th 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 1 of q");
-  if (NA_TYPE(rblapack_z) != NA_DFLOAT)
-    rblapack_z = na_change_type(rblapack_z, NA_DFLOAT);
-  z = NA_PTR_TYPE(rblapack_z, doublereal*);
-  if (!NA_IsNArray(rblapack_indxq))
-    rb_raise(rb_eArgError, "indxq (4th argument) must be NArray");
-  if (NA_RANK(rblapack_indxq) != 1)
-    rb_raise(rb_eArgError, "rank of indxq (4th 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 1 of q");
-  if (NA_TYPE(rblapack_indxq) != NA_LINT)
-    rblapack_indxq = na_change_type(rblapack_indxq, NA_LINT);
-  indxq = NA_PTR_TYPE(rblapack_indxq, integer*);
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_dlamda = na_make_object(NA_DFLOAT, 1, shape, cNArray);
-  }
-  dlamda = NA_PTR_TYPE(rblapack_dlamda, doublereal*);
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_w = na_make_object(NA_DFLOAT, 1, shape, cNArray);
-  }
-  w = NA_PTR_TYPE(rblapack_w, doublereal*);
-  {
-    int shape[1];
-    shape[0] = pow(n1,2)+pow(n-n1,2);
-    rblapack_q2 = na_make_object(NA_DFLOAT, 1, shape, cNArray);
-  }
-  q2 = NA_PTR_TYPE(rblapack_q2, doublereal*);
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_indxc = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  indxc = NA_PTR_TYPE(rblapack_indxc, integer*);
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_coltyp = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  coltyp = NA_PTR_TYPE(rblapack_coltyp, integer*);
-  {
-    int 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__;
-  {
-    int shape[2];
-    shape[0] = ldq;
-    shape[1] = 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__;
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_indxq_out__ = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  indxq_out__ = NA_PTR_TYPE(rblapack_indxq_out__, integer*);
-  MEMCPY(indxq_out__, indxq, integer, NA_TOTAL(rblapack_indxq));
-  rblapack_indxq = rblapack_indxq_out__;
-  indxq = indxq_out__;
-  indx = ALLOC_N(integer, (n));
-  indxp = ALLOC_N(integer, (n));
-
-  dlaed2_(&k, &n, &n1, d, q, &ldq, indxq, &rho, z, dlamda, w, q2, indx, indxc, indxp, coltyp, &info);
-
-  free(indx);
-  free(indxp);
-  rblapack_k = INT2NUM(k);
-  rblapack_info = INT2NUM(info);
-  rblapack_rho = rb_float_new((double)rho);
-  return rb_ary_new3(11, rblapack_k, rblapack_dlamda, rblapack_w, rblapack_q2, rblapack_indxc, rblapack_coltyp, rblapack_info, rblapack_d, rblapack_q, rblapack_indxq, rblapack_rho);
-}
-
-void
-init_lapack_dlaed2(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "dlaed2", rblapack_dlaed2, -1);
-}