ruby-lapack 1.6 → 1.7

data/ext/dlasdt.c

@@ -1,82 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID dlasdt_(integer* n, integer* lvl, integer* nd, integer* inode, integer* ndiml, integer* ndimr, integer* msub);
-
-
-static VALUE
-rblapack_dlasdt(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_n;
-  integer n; 
-  VALUE rblapack_msub;
-  integer msub; 
-  VALUE rblapack_lvl;
-  integer lvl; 
-  VALUE rblapack_nd;
-  integer nd; 
-  VALUE rblapack_inode;
-  integer *inode; 
-  VALUE rblapack_ndiml;
-  integer *ndiml; 
-  VALUE rblapack_ndimr;
-  integer *ndimr; 
-
-
-  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  lvl, nd, inode, ndiml, ndimr = NumRu::Lapack.dlasdt( n, msub, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLASDT( N, LVL, ND, INODE, NDIML, NDIMR, MSUB )\n\n*  Purpose\n*  =======\n*\n*  DLASDT creates a tree of subproblems for bidiagonal divide and\n*  conquer.\n*\n\n*  Arguments\n*  =========\n*\n*   N      (input) INTEGER\n*          On entry, the number of diagonal elements of the\n*          bidiagonal matrix.\n*\n*   LVL    (output) INTEGER\n*          On exit, the number of levels on the computation tree.\n*\n*   ND     (output) INTEGER\n*          On exit, the number of nodes on the tree.\n*\n*   INODE  (output) INTEGER array, dimension ( N )\n*          On exit, centers of subproblems.\n*\n*   NDIML  (output) INTEGER array, dimension ( N )\n*          On exit, row dimensions of left children.\n*\n*   NDIMR  (output) INTEGER array, dimension ( N )\n*          On exit, row dimensions of right children.\n*\n*   MSUB   (input) INTEGER\n*          On entry, the maximum row dimension each subproblem at the\n*          bottom of the tree can be of.\n*\n\n*  Further Details\n*  ===============\n*\n*  Based on contributions by\n*     Ming Gu and Huan Ren, Computer Science Division, University of\n*     California at Berkeley, USA\n*\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  lvl, nd, inode, ndiml, ndimr = NumRu::Lapack.dlasdt( n, msub, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 2 && argc != 2)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 2)", argc);
-  rblapack_n = argv[0];
-  rblapack_msub = argv[1];
-  if (argc == 2) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  n = NUM2INT(rblapack_n);
-  msub = NUM2INT(rblapack_msub);
-  {
-    int shape[1];
-    shape[0] = MAX(1,n);
-    rblapack_inode = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  inode = NA_PTR_TYPE(rblapack_inode, integer*);
-  {
-    int shape[1];
-    shape[0] = MAX(1,n);
-    rblapack_ndiml = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  ndiml = NA_PTR_TYPE(rblapack_ndiml, integer*);
-  {
-    int shape[1];
-    shape[0] = MAX(1,n);
-    rblapack_ndimr = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  ndimr = NA_PTR_TYPE(rblapack_ndimr, integer*);
-
-  dlasdt_(&n, &lvl, &nd, inode, ndiml, ndimr, &msub);
-
-  rblapack_lvl = INT2NUM(lvl);
-  rblapack_nd = INT2NUM(nd);
-  return rb_ary_new3(5, rblapack_lvl, rblapack_nd, rblapack_inode, rblapack_ndiml, rblapack_ndimr);
-}
-
-void
-init_lapack_dlasdt(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "dlasdt", rblapack_dlasdt, -1);
-}

data/ext/dlaset.c

@@ -1,86 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID dlaset_(char* uplo, integer* m, integer* n, doublereal* alpha, doublereal* beta, doublereal* a, integer* lda);
-
-
-static VALUE
-rblapack_dlaset(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_uplo;
-  char uplo; 
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_alpha;
-  doublereal alpha; 
-  VALUE rblapack_beta;
-  doublereal beta; 
-  VALUE rblapack_a;
-  doublereal *a; 
-  VALUE rblapack_a_out__;
-  doublereal *a_out__;
-
-  integer lda;
-  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  a = NumRu::Lapack.dlaset( uplo, m, alpha, beta, a, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLASET( UPLO, M, N, ALPHA, BETA, A, LDA )\n\n*  Purpose\n*  =======\n*\n*  DLASET initializes an m-by-n matrix A to BETA on the diagonal and\n*  ALPHA on the offdiagonals.\n*\n\n*  Arguments\n*  =========\n*\n*  UPLO    (input) CHARACTER*1\n*          Specifies the part of the matrix A to be set.\n*          = 'U':      Upper triangular part is set; the strictly lower\n*                      triangular part of A is not changed.\n*          = 'L':      Lower triangular part is set; the strictly upper\n*                      triangular part of A is not changed.\n*          Otherwise:  All of the matrix A is set.\n*\n*  M       (input) INTEGER\n*          The number of rows of the matrix A.  M >= 0.\n*\n*  N       (input) INTEGER\n*          The number of columns of the matrix A.  N >= 0.\n*\n*  ALPHA   (input) DOUBLE PRECISION\n*          The constant to which the offdiagonal elements are to be set.\n*\n*  BETA    (input) DOUBLE PRECISION\n*          The constant to which the diagonal elements are to be set.\n*\n*  A       (input/output) DOUBLE PRECISION array, dimension (LDA,N)\n*          On exit, the leading m-by-n submatrix of A is set as follows:\n*\n*          if UPLO = 'U', A(i,j) = ALPHA, 1<=i<=j-1, 1<=j<=n,\n*          if UPLO = 'L', A(i,j) = ALPHA, j+1<=i<=m, 1<=j<=n,\n*          otherwise,     A(i,j) = ALPHA, 1<=i<=m, 1<=j<=n, i.ne.j,\n*\n*          and, for all UPLO, A(i,i) = BETA, 1<=i<=min(m,n).\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A.  LDA >= max(1,M).\n*\n\n* =====================================================================\n*\n*     .. Local Scalars ..\n      INTEGER            I, J\n*     ..\n*     .. External Functions ..\n      LOGICAL            LSAME\n      EXTERNAL           LSAME\n*     ..\n*     .. Intrinsic Functions ..\n      INTRINSIC          MIN\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  a = NumRu::Lapack.dlaset( uplo, m, alpha, beta, a, [: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_uplo = argv[0];
-  rblapack_m = argv[1];
-  rblapack_alpha = argv[2];
-  rblapack_beta = argv[3];
-  rblapack_a = argv[4];
-  if (argc == 5) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  uplo = StringValueCStr(rblapack_uplo)[0];
-  alpha = NUM2DBL(rblapack_alpha);
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (5th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (5th argument) must be %d", 2);
-  lda = NA_SHAPE0(rblapack_a);
-  n = NA_SHAPE1(rblapack_a);
-  if (NA_TYPE(rblapack_a) != NA_DFLOAT)
-    rblapack_a = na_change_type(rblapack_a, NA_DFLOAT);
-  a = NA_PTR_TYPE(rblapack_a, doublereal*);
-  m = NUM2INT(rblapack_m);
-  beta = NUM2DBL(rblapack_beta);
-  {
-    int shape[2];
-    shape[0] = lda;
-    shape[1] = n;
-    rblapack_a_out__ = na_make_object(NA_DFLOAT, 2, shape, cNArray);
-  }
-  a_out__ = NA_PTR_TYPE(rblapack_a_out__, doublereal*);
-  MEMCPY(a_out__, a, doublereal, NA_TOTAL(rblapack_a));
-  rblapack_a = rblapack_a_out__;
-  a = a_out__;
-
-  dlaset_(&uplo, &m, &n, &alpha, &beta, a, &lda);
-
-  return rblapack_a;
-}
-
-void
-init_lapack_dlaset(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "dlaset", rblapack_dlaset, -1);
-}

data/ext/dlasq1.c

@@ -1,96 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID dlasq1_(integer* n, doublereal* d, doublereal* e, doublereal* work, integer* info);
-
-
-static VALUE
-rblapack_dlasq1(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_d;
-  doublereal *d; 
-  VALUE rblapack_e;
-  doublereal *e; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack_d_out__;
-  doublereal *d_out__;
-  VALUE rblapack_e_out__;
-  doublereal *e_out__;
-  doublereal *work;
-
-  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  info, d, e = NumRu::Lapack.dlasq1( d, e, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLASQ1( N, D, E, WORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  DLASQ1 computes the singular values of a real N-by-N bidiagonal\n*  matrix with diagonal D and off-diagonal E. The singular values\n*  are computed to high relative accuracy, in the absence of\n*  denormalization, underflow and overflow. The algorithm was first\n*  presented in\n*\n*  \"Accurate singular values and differential qd algorithms\" by K. V.\n*  Fernando and B. N. Parlett, Numer. Math., Vol-67, No. 2, pp. 191-230,\n*  1994,\n*\n*  and the present implementation is described in \"An implementation of\n*  the dqds Algorithm (Positive Case)\", LAPACK Working Note.\n*\n\n*  Arguments\n*  =========\n*\n*  N     (input) INTEGER\n*        The number of rows and columns in the matrix. N >= 0.\n*\n*  D     (input/output) DOUBLE PRECISION array, dimension (N)\n*        On entry, D contains the diagonal elements of the\n*        bidiagonal matrix whose SVD is desired. On normal exit,\n*        D contains the singular values in decreasing order.\n*\n*  E     (input/output) DOUBLE PRECISION array, dimension (N)\n*        On entry, elements E(1:N-1) contain the off-diagonal elements\n*        of the bidiagonal matrix whose SVD is desired.\n*        On exit, E is overwritten.\n*\n*  WORK  (workspace) DOUBLE PRECISION 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: the algorithm failed\n*             = 1, a split was marked by a positive value in E\n*             = 2, current block of Z not diagonalized after 30*N\n*                  iterations (in inner while loop)\n*             = 3, termination criterion of outer while loop not met \n*                  (program created more than N unreduced blocks)\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  info, d, e = NumRu::Lapack.dlasq1( d, e, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 2 && argc != 2)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 2)", argc);
-  rblapack_d = argv[0];
-  rblapack_e = argv[1];
-  if (argc == 2) {
-  } 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_e))
-    rb_raise(rb_eArgError, "e (2th argument) must be NArray");
-  if (NA_RANK(rblapack_e) != 1)
-    rb_raise(rb_eArgError, "rank of e (2th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_e) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of e must be the same as shape 0 of d");
-  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[1];
-    shape[0] = n;
-    rblapack_e_out__ = na_make_object(NA_DFLOAT, 1, shape, cNArray);
-  }
-  e_out__ = NA_PTR_TYPE(rblapack_e_out__, doublereal*);
-  MEMCPY(e_out__, e, doublereal, NA_TOTAL(rblapack_e));
-  rblapack_e = rblapack_e_out__;
-  e = e_out__;
-  work = ALLOC_N(doublereal, (4*n));
-
-  dlasq1_(&n, d, e, work, &info);
-
-  free(work);
-  rblapack_info = INT2NUM(info);
-  return rb_ary_new3(3, rblapack_info, rblapack_d, rblapack_e);
-}
-
-void
-init_lapack_dlasq1(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "dlasq1", rblapack_dlasq1, -1);
-}

data/ext/dlasq2.c

@@ -1,74 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID dlasq2_(integer* n, doublereal* z, integer* info);
-
-
-static VALUE
-rblapack_dlasq2(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_n;
-  integer n; 
-  VALUE rblapack_z;
-  doublereal *z; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack_z_out__;
-  doublereal *z_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  info, z = NumRu::Lapack.dlasq2( n, z, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLASQ2( N, Z, INFO )\n\n*  Purpose\n*  =======\n*\n*  DLASQ2 computes all the eigenvalues of the symmetric positive \n*  definite tridiagonal matrix associated with the qd array Z to high\n*  relative accuracy are computed to high relative accuracy, in the\n*  absence of denormalization, underflow and overflow.\n*\n*  To see the relation of Z to the tridiagonal matrix, let L be a\n*  unit lower bidiagonal matrix with subdiagonals Z(2,4,6,,..) and\n*  let U be an upper bidiagonal matrix with 1's above and diagonal\n*  Z(1,3,5,,..). The tridiagonal is L*U or, if you prefer, the\n*  symmetric tridiagonal to which it is similar.\n*\n*  Note : DLASQ2 defines a logical variable, IEEE, which is true\n*  on machines which follow ieee-754 floating-point standard in their\n*  handling of infinities and NaNs, and false otherwise. This variable\n*  is passed to DLASQ3.\n*\n\n*  Arguments\n*  =========\n*\n*  N     (input) INTEGER\n*        The number of rows and columns in the matrix. N >= 0.\n*\n*  Z     (input/output) DOUBLE PRECISION array, dimension ( 4*N )\n*        On entry Z holds the qd array. On exit, entries 1 to N hold\n*        the eigenvalues in decreasing order, Z( 2*N+1 ) holds the\n*        trace, and Z( 2*N+2 ) holds the sum of the eigenvalues. If\n*        N > 2, then Z( 2*N+3 ) holds the iteration count, Z( 2*N+4 )\n*        holds NDIVS/NIN^2, and Z( 2*N+5 ) holds the percentage of\n*        shifts that failed.\n*\n*  INFO  (output) INTEGER\n*        = 0: successful exit\n*        < 0: if the i-th argument is a scalar and had an illegal\n*             value, then INFO = -i, if the i-th argument is an\n*             array and the j-entry had an illegal value, then\n*             INFO = -(i*100+j)\n*        > 0: the algorithm failed\n*              = 1, a split was marked by a positive value in E\n*              = 2, current block of Z not diagonalized after 30*N\n*                   iterations (in inner while loop)\n*              = 3, termination criterion of outer while loop not met \n*                   (program created more than N unreduced blocks)\n*\n\n*  Further Details\n*  ===============\n*  Local Variables: I0:N0 defines a current unreduced segment of Z.\n*  The shifts are accumulated in SIGMA. Iteration count is in ITER.\n*  Ping-pong is controlled by PP (alternates between 0 and 1).\n*\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  info, z = NumRu::Lapack.dlasq2( n, z, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 2 && argc != 2)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 2)", argc);
-  rblapack_n = argv[0];
-  rblapack_z = argv[1];
-  if (argc == 2) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  n = NUM2INT(rblapack_n);
-  if (!NA_IsNArray(rblapack_z))
-    rb_raise(rb_eArgError, "z (2th argument) must be NArray");
-  if (NA_RANK(rblapack_z) != 1)
-    rb_raise(rb_eArgError, "rank of z (2th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_z) != (4*n))
-    rb_raise(rb_eRuntimeError, "shape 0 of z must be %d", 4*n);
-  if (NA_TYPE(rblapack_z) != NA_DFLOAT)
-    rblapack_z = na_change_type(rblapack_z, NA_DFLOAT);
-  z = NA_PTR_TYPE(rblapack_z, doublereal*);
-  {
-    int shape[1];
-    shape[0] = 4*n;
-    rblapack_z_out__ = na_make_object(NA_DFLOAT, 1, 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__;
-
-  dlasq2_(&n, z, &info);
-
-  rblapack_info = INT2NUM(info);
-  return rb_ary_new3(2, rblapack_info, rblapack_z);
-}
-
-void
-init_lapack_dlasq2(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "dlasq2", rblapack_dlasq2, -1);
-}

data/ext/dlasq3.c

@@ -1,138 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID dlasq3_(integer* i0, integer* n0, doublereal* z, integer* pp, doublereal* dmin, doublereal* sigma, doublereal* desig, doublereal* qmax, integer* nfail, integer* iter, integer* ndiv, logical* ieee, integer* ttype, doublereal* dmin1, doublereal* dmin2, doublereal* dn, doublereal* dn1, doublereal* dn2, doublereal* g, doublereal* tau);
-
-
-static VALUE
-rblapack_dlasq3(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_i0;
-  integer i0; 
-  VALUE rblapack_n0;
-  integer n0; 
-  VALUE rblapack_z;
-  doublereal *z; 
-  VALUE rblapack_pp;
-  integer pp; 
-  VALUE rblapack_desig;
-  doublereal desig; 
-  VALUE rblapack_qmax;
-  doublereal qmax; 
-  VALUE rblapack_ieee;
-  logical ieee; 
-  VALUE rblapack_ttype;
-  integer ttype; 
-  VALUE rblapack_dmin1;
-  doublereal dmin1; 
-  VALUE rblapack_dmin2;
-  doublereal dmin2; 
-  VALUE rblapack_dn;
-  doublereal dn; 
-  VALUE rblapack_dn1;
-  doublereal dn1; 
-  VALUE rblapack_dn2;
-  doublereal dn2; 
-  VALUE rblapack_g;
-  doublereal g; 
-  VALUE rblapack_tau;
-  doublereal tau; 
-  VALUE rblapack_dmin;
-  doublereal dmin; 
-  VALUE rblapack_sigma;
-  doublereal sigma; 
-  VALUE rblapack_nfail;
-  integer nfail; 
-  VALUE rblapack_iter;
-  integer iter; 
-  VALUE rblapack_ndiv;
-  integer ndiv; 
-
-
-  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  dmin, sigma, nfail, iter, ndiv, n0, pp, desig, ttype, dmin1, dmin2, dn, dn1, dn2, g, tau = NumRu::Lapack.dlasq3( i0, n0, z, pp, desig, qmax, ieee, ttype, dmin1, dmin2, dn, dn1, dn2, g, tau, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLASQ3( I0, N0, Z, PP, DMIN, SIGMA, DESIG, QMAX, NFAIL, ITER, NDIV, IEEE, TTYPE, DMIN1, DMIN2, DN, DN1, DN2, G, TAU )\n\n*  Purpose\n*  =======\n*\n*  DLASQ3 checks for deflation, computes a shift (TAU) and calls dqds.\n*  In case of failure it changes shifts, and tries again until output\n*  is positive.\n*\n\n*  Arguments\n*  =========\n*\n*  I0     (input) INTEGER\n*         First index.\n*\n*  N0     (input/output) INTEGER\n*         Last index.\n*\n*  Z      (input) DOUBLE PRECISION array, dimension ( 4*N )\n*         Z holds the qd array.\n*\n*  PP     (input/output) INTEGER\n*         PP=0 for ping, PP=1 for pong.\n*         PP=2 indicates that flipping was applied to the Z array   \n*         and that the initial tests for deflation should not be \n*         performed.\n*\n*  DMIN   (output) DOUBLE PRECISION\n*         Minimum value of d.\n*\n*  SIGMA  (output) DOUBLE PRECISION\n*         Sum of shifts used in current segment.\n*\n*  DESIG  (input/output) DOUBLE PRECISION\n*         Lower order part of SIGMA\n*\n*  QMAX   (input) DOUBLE PRECISION\n*         Maximum value of q.\n*\n*  NFAIL  (output) INTEGER\n*         Number of times shift was too big.\n*\n*  ITER   (output) INTEGER\n*         Number of iterations.\n*\n*  NDIV   (output) INTEGER\n*         Number of divisions.\n*\n*  IEEE   (input) LOGICAL\n*         Flag for IEEE or non IEEE arithmetic (passed to DLASQ5).\n*\n*  TTYPE  (input/output) INTEGER\n*         Shift type.\n*\n*  DMIN1  (input/output) DOUBLE PRECISION\n*\n*  DMIN2  (input/output) DOUBLE PRECISION\n*\n*  DN     (input/output) DOUBLE PRECISION\n*\n*  DN1    (input/output) DOUBLE PRECISION\n*\n*  DN2    (input/output) DOUBLE PRECISION\n*\n*  G      (input/output) DOUBLE PRECISION\n*\n*  TAU    (input/output) DOUBLE PRECISION\n*\n*         These are passed as arguments in order to save their values\n*         between calls to DLASQ3.\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  dmin, sigma, nfail, iter, ndiv, n0, pp, desig, ttype, dmin1, dmin2, dn, dn1, dn2, g, tau = NumRu::Lapack.dlasq3( i0, n0, z, pp, desig, qmax, ieee, ttype, dmin1, dmin2, dn, dn1, dn2, g, tau, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 15 && argc != 15)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 15)", argc);
-  rblapack_i0 = argv[0];
-  rblapack_n0 = argv[1];
-  rblapack_z = argv[2];
-  rblapack_pp = argv[3];
-  rblapack_desig = argv[4];
-  rblapack_qmax = argv[5];
-  rblapack_ieee = argv[6];
-  rblapack_ttype = argv[7];
-  rblapack_dmin1 = argv[8];
-  rblapack_dmin2 = argv[9];
-  rblapack_dn = argv[10];
-  rblapack_dn1 = argv[11];
-  rblapack_dn2 = argv[12];
-  rblapack_g = argv[13];
-  rblapack_tau = argv[14];
-  if (argc == 15) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  i0 = NUM2INT(rblapack_i0);
-  pp = NUM2INT(rblapack_pp);
-  qmax = NUM2DBL(rblapack_qmax);
-  ttype = NUM2INT(rblapack_ttype);
-  dmin2 = NUM2DBL(rblapack_dmin2);
-  dn1 = NUM2DBL(rblapack_dn1);
-  g = NUM2DBL(rblapack_g);
-  n0 = NUM2INT(rblapack_n0);
-  desig = NUM2DBL(rblapack_desig);
-  dmin1 = NUM2DBL(rblapack_dmin1);
-  dn2 = NUM2DBL(rblapack_dn2);
-  if (!NA_IsNArray(rblapack_z))
-    rb_raise(rb_eArgError, "z (3th argument) must be NArray");
-  if (NA_RANK(rblapack_z) != 1)
-    rb_raise(rb_eArgError, "rank of z (3th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_z) != (4*n0))
-    rb_raise(rb_eRuntimeError, "shape 0 of z must be %d", 4*n0);
-  if (NA_TYPE(rblapack_z) != NA_DFLOAT)
-    rblapack_z = na_change_type(rblapack_z, NA_DFLOAT);
-  z = NA_PTR_TYPE(rblapack_z, doublereal*);
-  dn = NUM2DBL(rblapack_dn);
-  ieee = (rblapack_ieee == Qtrue);
-  tau = NUM2DBL(rblapack_tau);
-
-  dlasq3_(&i0, &n0, z, &pp, &dmin, &sigma, &desig, &qmax, &nfail, &iter, &ndiv, &ieee, &ttype, &dmin1, &dmin2, &dn, &dn1, &dn2, &g, &tau);
-
-  rblapack_dmin = rb_float_new((double)dmin);
-  rblapack_sigma = rb_float_new((double)sigma);
-  rblapack_nfail = INT2NUM(nfail);
-  rblapack_iter = INT2NUM(iter);
-  rblapack_ndiv = INT2NUM(ndiv);
-  rblapack_n0 = INT2NUM(n0);
-  rblapack_pp = INT2NUM(pp);
-  rblapack_desig = rb_float_new((double)desig);
-  rblapack_ttype = INT2NUM(ttype);
-  rblapack_dmin1 = rb_float_new((double)dmin1);
-  rblapack_dmin2 = rb_float_new((double)dmin2);
-  rblapack_dn = rb_float_new((double)dn);
-  rblapack_dn1 = rb_float_new((double)dn1);
-  rblapack_dn2 = rb_float_new((double)dn2);
-  rblapack_g = rb_float_new((double)g);
-  rblapack_tau = rb_float_new((double)tau);
-  return rb_ary_new3(16, rblapack_dmin, rblapack_sigma, rblapack_nfail, rblapack_iter, rblapack_ndiv, rblapack_n0, rblapack_pp, rblapack_desig, rblapack_ttype, rblapack_dmin1, rblapack_dmin2, rblapack_dn, rblapack_dn1, rblapack_dn2, rblapack_g, rblapack_tau);
-}
-
-void
-init_lapack_dlasq3(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "dlasq3", rblapack_dlasq3, -1);
-}