ruby-lapack 1.7 → 1.7.1

data/ext/dlargv.c

@@ -0,0 +1,114 @@
+#include "rb_lapack.h"
+
+extern VOID dlargv_(integer* n, doublereal* x, integer* incx, doublereal* y, integer* incy, doublereal* c, integer* incc);
+
+
+static VALUE
+rblapack_dlargv(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_n;
+  integer n; 
+  VALUE rblapack_x;
+  doublereal *x; 
+  VALUE rblapack_incx;
+  integer incx; 
+  VALUE rblapack_y;
+  doublereal *y; 
+  VALUE rblapack_incy;
+  integer incy; 
+  VALUE rblapack_incc;
+  integer incc; 
+  VALUE rblapack_c;
+  doublereal *c; 
+  VALUE rblapack_x_out__;
+  doublereal *x_out__;
+  VALUE rblapack_y_out__;
+  doublereal *y_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  c, x, y = NumRu::Lapack.dlargv( n, x, incx, y, incy, incc, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLARGV( N, X, INCX, Y, INCY, C, INCC )\n\n*  Purpose\n*  =======\n*\n*  DLARGV generates a vector of real plane rotations, determined by\n*  elements of the real vectors x and y. For i = 1,2,...,n\n*\n*     (  c(i)  s(i) ) ( x(i) ) = ( a(i) )\n*     ( -s(i)  c(i) ) ( y(i) ) = (   0  )\n*\n\n*  Arguments\n*  =========\n*\n*  N       (input) INTEGER\n*          The number of plane rotations to be generated.\n*\n*  X       (input/output) DOUBLE PRECISION array,\n*                         dimension (1+(N-1)*INCX)\n*          On entry, the vector x.\n*          On exit, x(i) is overwritten by a(i), for i = 1,...,n.\n*\n*  INCX    (input) INTEGER\n*          The increment between elements of X. INCX > 0.\n*\n*  Y       (input/output) DOUBLE PRECISION array,\n*                         dimension (1+(N-1)*INCY)\n*          On entry, the vector y.\n*          On exit, the sines of the plane rotations.\n*\n*  INCY    (input) INTEGER\n*          The increment between elements of Y. INCY > 0.\n*\n*  C       (output) DOUBLE PRECISION array, dimension (1+(N-1)*INCC)\n*          The cosines of the plane rotations.\n*\n*  INCC    (input) INTEGER\n*          The increment between elements of C. INCC > 0.\n*\n\n*  =====================================================================\n*\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  c, x, y = NumRu::Lapack.dlargv( n, x, incx, y, incy, incc, [: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_n = argv[0];
+  rblapack_x = argv[1];
+  rblapack_incx = argv[2];
+  rblapack_y = argv[3];
+  rblapack_incy = argv[4];
+  rblapack_incc = argv[5];
+  if (argc == 6) {
+  } else if (rblapack_options != Qnil) {
+  } else {
+  }
+
+  n = NUM2INT(rblapack_n);
+  incx = NUM2INT(rblapack_incx);
+  incy = NUM2INT(rblapack_incy);
+  if (!NA_IsNArray(rblapack_x))
+    rb_raise(rb_eArgError, "x (2th argument) must be NArray");
+  if (NA_RANK(rblapack_x) != 1)
+    rb_raise(rb_eArgError, "rank of x (2th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_x) != (1+(n-1)*incx))
+    rb_raise(rb_eRuntimeError, "shape 0 of x must be %d", 1+(n-1)*incx);
+  if (NA_TYPE(rblapack_x) != NA_DFLOAT)
+    rblapack_x = na_change_type(rblapack_x, NA_DFLOAT);
+  x = NA_PTR_TYPE(rblapack_x, doublereal*);
+  incc = NUM2INT(rblapack_incc);
+  if (!NA_IsNArray(rblapack_y))
+    rb_raise(rb_eArgError, "y (4th argument) must be NArray");
+  if (NA_RANK(rblapack_y) != 1)
+    rb_raise(rb_eArgError, "rank of y (4th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_y) != (1+(n-1)*incy))
+    rb_raise(rb_eRuntimeError, "shape 0 of y must be %d", 1+(n-1)*incy);
+  if (NA_TYPE(rblapack_y) != NA_DFLOAT)
+    rblapack_y = na_change_type(rblapack_y, NA_DFLOAT);
+  y = NA_PTR_TYPE(rblapack_y, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = 1+(n-1)*incc;
+    rblapack_c = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  c = NA_PTR_TYPE(rblapack_c, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = 1+(n-1)*incx;
+    rblapack_x_out__ = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  x_out__ = NA_PTR_TYPE(rblapack_x_out__, doublereal*);
+  MEMCPY(x_out__, x, doublereal, NA_TOTAL(rblapack_x));
+  rblapack_x = rblapack_x_out__;
+  x = x_out__;
+  {
+    na_shape_t shape[1];
+    shape[0] = 1+(n-1)*incy;
+    rblapack_y_out__ = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  y_out__ = NA_PTR_TYPE(rblapack_y_out__, doublereal*);
+  MEMCPY(y_out__, y, doublereal, NA_TOTAL(rblapack_y));
+  rblapack_y = rblapack_y_out__;
+  y = y_out__;
+
+  dlargv_(&n, x, &incx, y, &incy, c, &incc);
+
+  return rb_ary_new3(3, rblapack_c, rblapack_x, rblapack_y);
+}
+
+void
+init_lapack_dlargv(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "dlargv", rblapack_dlargv, -1);
+}

data/ext/dlarnv.c

@@ -0,0 +1,83 @@
+#include "rb_lapack.h"
+
+extern VOID dlarnv_(integer* idist, integer* iseed, integer* n, doublereal* x);
+
+
+static VALUE
+rblapack_dlarnv(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_idist;
+  integer idist; 
+  VALUE rblapack_iseed;
+  integer *iseed; 
+  VALUE rblapack_n;
+  integer n; 
+  VALUE rblapack_x;
+  doublereal *x; 
+  VALUE rblapack_iseed_out__;
+  integer *iseed_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  x, iseed = NumRu::Lapack.dlarnv( idist, iseed, n, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLARNV( IDIST, ISEED, N, X )\n\n*  Purpose\n*  =======\n*\n*  DLARNV returns a vector of n random real numbers from a uniform or\n*  normal distribution.\n*\n\n*  Arguments\n*  =========\n*\n*  IDIST   (input) INTEGER\n*          Specifies the distribution of the random numbers:\n*          = 1:  uniform (0,1)\n*          = 2:  uniform (-1,1)\n*          = 3:  normal (0,1)\n*\n*  ISEED   (input/output) INTEGER array, dimension (4)\n*          On entry, the seed of the random number generator; the array\n*          elements must be between 0 and 4095, and ISEED(4) must be\n*          odd.\n*          On exit, the seed is updated.\n*\n*  N       (input) INTEGER\n*          The number of random numbers to be generated.\n*\n*  X       (output) DOUBLE PRECISION array, dimension (N)\n*          The generated random numbers.\n*\n\n*  Further Details\n*  ===============\n*\n*  This routine calls the auxiliary routine DLARUV to generate random\n*  real numbers from a uniform (0,1) distribution, in batches of up to\n*  128 using vectorisable code. The Box-Muller method is used to\n*  transform numbers from a uniform to a normal distribution.\n*\n*  =====================================================================\n*\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  x, iseed = NumRu::Lapack.dlarnv( idist, iseed, n, [:usage => usage, :help => help])\n");
+      return Qnil;
+    } 
+  } else
+    rblapack_options = Qnil;
+  if (argc != 3 && argc != 3)
+    rb_raise(rb_eArgError,"wrong number of arguments (%d for 3)", argc);
+  rblapack_idist = argv[0];
+  rblapack_iseed = argv[1];
+  rblapack_n = argv[2];
+  if (argc == 3) {
+  } else if (rblapack_options != Qnil) {
+  } else {
+  }
+
+  idist = NUM2INT(rblapack_idist);
+  n = NUM2INT(rblapack_n);
+  if (!NA_IsNArray(rblapack_iseed))
+    rb_raise(rb_eArgError, "iseed (2th argument) must be NArray");
+  if (NA_RANK(rblapack_iseed) != 1)
+    rb_raise(rb_eArgError, "rank of iseed (2th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_iseed) != (4))
+    rb_raise(rb_eRuntimeError, "shape 0 of iseed must be %d", 4);
+  if (NA_TYPE(rblapack_iseed) != NA_LINT)
+    rblapack_iseed = na_change_type(rblapack_iseed, NA_LINT);
+  iseed = NA_PTR_TYPE(rblapack_iseed, integer*);
+  {
+    na_shape_t shape[1];
+    shape[0] = MAX(1,n);
+    rblapack_x = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  x = NA_PTR_TYPE(rblapack_x, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = 4;
+    rblapack_iseed_out__ = na_make_object(NA_LINT, 1, shape, cNArray);
+  }
+  iseed_out__ = NA_PTR_TYPE(rblapack_iseed_out__, integer*);
+  MEMCPY(iseed_out__, iseed, integer, NA_TOTAL(rblapack_iseed));
+  rblapack_iseed = rblapack_iseed_out__;
+  iseed = iseed_out__;
+
+  dlarnv_(&idist, iseed, &n, x);
+
+  return rb_ary_new3(2, rblapack_x, rblapack_iseed);
+}
+
+void
+init_lapack_dlarnv(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "dlarnv", rblapack_dlarnv, -1);
+}

data/ext/dlarra.c

@@ -0,0 +1,124 @@
+#include "rb_lapack.h"
+
+extern VOID dlarra_(integer* n, doublereal* d, doublereal* e, doublereal* e2, doublereal* spltol, doublereal* tnrm, integer* nsplit, integer* isplit, integer* info);
+
+
+static VALUE
+rblapack_dlarra(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_d;
+  doublereal *d; 
+  VALUE rblapack_e;
+  doublereal *e; 
+  VALUE rblapack_e2;
+  doublereal *e2; 
+  VALUE rblapack_spltol;
+  doublereal spltol; 
+  VALUE rblapack_tnrm;
+  doublereal tnrm; 
+  VALUE rblapack_nsplit;
+  integer nsplit; 
+  VALUE rblapack_isplit;
+  integer *isplit; 
+  VALUE rblapack_info;
+  integer info; 
+  VALUE rblapack_e_out__;
+  doublereal *e_out__;
+  VALUE rblapack_e2_out__;
+  doublereal *e2_out__;
+
+  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  nsplit, isplit, info, e, e2 = NumRu::Lapack.dlarra( d, e, e2, spltol, tnrm, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLARRA( N, D, E, E2, SPLTOL, TNRM, NSPLIT, ISPLIT, INFO )\n\n*  Purpose\n*  =======\n*\n*  Compute the splitting points with threshold SPLTOL.\n*  DLARRA sets any \"small\" off-diagonal elements to zero.\n*\n\n*  Arguments\n*  =========\n*\n*  N       (input) INTEGER\n*          The order of the matrix. N > 0.\n*\n*  D       (input) DOUBLE PRECISION array, dimension (N)\n*          On entry, the N diagonal elements of the tridiagonal\n*          matrix T.\n*\n*  E       (input/output) DOUBLE PRECISION array, dimension (N)\n*          On entry, the first (N-1) entries contain the subdiagonal\n*          elements of the tridiagonal matrix T; E(N) need not be set.\n*          On exit, the entries E( ISPLIT( I ) ), 1 <= I <= NSPLIT,\n*          are set to zero, the other entries of E are untouched.\n*\n*  E2      (input/output) DOUBLE PRECISION array, dimension (N)\n*          On entry, the first (N-1) entries contain the SQUARES of the\n*          subdiagonal elements of the tridiagonal matrix T;\n*          E2(N) need not be set.\n*          On exit, the entries E2( ISPLIT( I ) ),\n*          1 <= I <= NSPLIT, have been set to zero\n*\n*  SPLTOL  (input) DOUBLE PRECISION\n*          The threshold for splitting. Two criteria can be used:\n*          SPLTOL<0 : criterion based on absolute off-diagonal value\n*          SPLTOL>0 : criterion that preserves relative accuracy\n*\n*  TNRM    (input) DOUBLE PRECISION\n*          The norm of the matrix.\n*\n*  NSPLIT  (output) INTEGER\n*          The number of blocks T splits into. 1 <= NSPLIT <= N.\n*\n*  ISPLIT  (output) INTEGER array, dimension (N)\n*          The splitting points, at which T breaks up into blocks.\n*          The first block consists of rows/columns 1 to ISPLIT(1),\n*          the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),\n*          etc., and the NSPLIT-th consists of rows/columns\n*          ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N.\n*\n*\n*  INFO    (output) INTEGER\n*          = 0:  successful exit\n*\n\n*  Further Details\n*  ===============\n*\n*  Based on contributions by\n*     Beresford Parlett, University of California, Berkeley, USA\n*     Jim Demmel, University of California, Berkeley, USA\n*     Inderjit Dhillon, University of Texas, Austin, USA\n*     Osni Marques, LBNL/NERSC, USA\n*     Christof Voemel, University of California, Berkeley, USA\n*\n*  =====================================================================\n*\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  nsplit, isplit, info, e, e2 = NumRu::Lapack.dlarra( d, e, e2, spltol, tnrm, [: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_e = argv[1];
+  rblapack_e2 = argv[2];
+  rblapack_spltol = argv[3];
+  rblapack_tnrm = 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_e2))
+    rb_raise(rb_eArgError, "e2 (3th argument) must be NArray");
+  if (NA_RANK(rblapack_e2) != 1)
+    rb_raise(rb_eArgError, "rank of e2 (3th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_e2) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of e2 must be the same as shape 0 of d");
+  if (NA_TYPE(rblapack_e2) != NA_DFLOAT)
+    rblapack_e2 = na_change_type(rblapack_e2, NA_DFLOAT);
+  e2 = NA_PTR_TYPE(rblapack_e2, doublereal*);
+  tnrm = NUM2DBL(rblapack_tnrm);
+  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*);
+  spltol = NUM2DBL(rblapack_spltol);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_isplit = na_make_object(NA_LINT, 1, shape, cNArray);
+  }
+  isplit = NA_PTR_TYPE(rblapack_isplit, integer*);
+  {
+    na_shape_t 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__;
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_e2_out__ = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  e2_out__ = NA_PTR_TYPE(rblapack_e2_out__, doublereal*);
+  MEMCPY(e2_out__, e2, doublereal, NA_TOTAL(rblapack_e2));
+  rblapack_e2 = rblapack_e2_out__;
+  e2 = e2_out__;
+
+  dlarra_(&n, d, e, e2, &spltol, &tnrm, &nsplit, isplit, &info);
+
+  rblapack_nsplit = INT2NUM(nsplit);
+  rblapack_info = INT2NUM(info);
+  return rb_ary_new3(5, rblapack_nsplit, rblapack_isplit, rblapack_info, rblapack_e, rblapack_e2);
+}
+
+void
+init_lapack_dlarra(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "dlarra", rblapack_dlarra, -1);
+}

data/ext/dlarrb.c

@@ -0,0 +1,178 @@
+#include "rb_lapack.h"
+
+extern VOID dlarrb_(integer* n, doublereal* d, doublereal* lld, integer* ifirst, integer* ilast, doublereal* rtol1, doublereal* rtol2, integer* offset, doublereal* w, doublereal* wgap, doublereal* werr, doublereal* work, integer* iwork, doublereal* pivmin, doublereal* spdiam, integer* twist, integer* info);
+
+
+static VALUE
+rblapack_dlarrb(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_d;
+  doublereal *d; 
+  VALUE rblapack_lld;
+  doublereal *lld; 
+  VALUE rblapack_ifirst;
+  integer ifirst; 
+  VALUE rblapack_ilast;
+  integer ilast; 
+  VALUE rblapack_rtol1;
+  doublereal rtol1; 
+  VALUE rblapack_rtol2;
+  doublereal rtol2; 
+  VALUE rblapack_offset;
+  integer offset; 
+  VALUE rblapack_w;
+  doublereal *w; 
+  VALUE rblapack_wgap;
+  doublereal *wgap; 
+  VALUE rblapack_werr;
+  doublereal *werr; 
+  VALUE rblapack_pivmin;
+  doublereal pivmin; 
+  VALUE rblapack_spdiam;
+  doublereal spdiam; 
+  VALUE rblapack_twist;
+  integer twist; 
+  VALUE rblapack_info;
+  integer info; 
+  VALUE rblapack_w_out__;
+  doublereal *w_out__;
+  VALUE rblapack_wgap_out__;
+  doublereal *wgap_out__;
+  VALUE rblapack_werr_out__;
+  doublereal *werr_out__;
+  doublereal *work;
+  integer *iwork;
+
+  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, w, wgap, werr = NumRu::Lapack.dlarrb( d, lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin, spdiam, twist, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE DLARRB( N, D, LLD, IFIRST, ILAST, RTOL1, RTOL2, OFFSET, W, WGAP, WERR, WORK, IWORK, PIVMIN, SPDIAM, TWIST, INFO )\n\n*  Purpose\n*  =======\n*\n*  Given the relatively robust representation(RRR) L D L^T, DLARRB\n*  does \"limited\" bisection to refine the eigenvalues of L D L^T,\n*  W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial\n*  guesses for these eigenvalues are input in W, the corresponding estimate\n*  of the error in these guesses and their gaps are input in WERR\n*  and WGAP, respectively. During bisection, intervals\n*  [left, right] are maintained by storing their mid-points and\n*  semi-widths in the arrays W and WERR respectively.\n*\n\n*  Arguments\n*  =========\n*\n*  N       (input) INTEGER\n*          The order of the matrix.\n*\n*  D       (input) DOUBLE PRECISION array, dimension (N)\n*          The N diagonal elements of the diagonal matrix D.\n*\n*  LLD     (input) DOUBLE PRECISION array, dimension (N-1)\n*          The (N-1) elements L(i)*L(i)*D(i).\n*\n*  IFIRST  (input) INTEGER\n*          The index of the first eigenvalue to be computed.\n*\n*  ILAST   (input) INTEGER\n*          The index of the last eigenvalue to be computed.\n*\n*  RTOL1   (input) DOUBLE PRECISION\n*  RTOL2   (input) DOUBLE PRECISION\n*          Tolerance for the convergence of the bisection intervals.\n*          An interval [LEFT,RIGHT] has converged if\n*          RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )\n*          where GAP is the (estimated) distance to the nearest\n*          eigenvalue.\n*\n*  OFFSET  (input) INTEGER\n*          Offset for the arrays W, WGAP and WERR, i.e., the IFIRST-OFFSET\n*          through ILAST-OFFSET elements of these arrays are to be used.\n*\n*  W       (input/output) DOUBLE PRECISION array, dimension (N)\n*          On input, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ) are\n*          estimates of the eigenvalues of L D L^T indexed IFIRST throug\n*          ILAST.\n*          On output, these estimates are refined.\n*\n*  WGAP    (input/output) DOUBLE PRECISION array, dimension (N-1)\n*          On input, the (estimated) gaps between consecutive\n*          eigenvalues of L D L^T, i.e., WGAP(I-OFFSET) is the gap between\n*          eigenvalues I and I+1. Note that if IFIRST.EQ.ILAST\n*          then WGAP(IFIRST-OFFSET) must be set to ZERO.\n*          On output, these gaps are refined.\n*\n*  WERR    (input/output) DOUBLE PRECISION array, dimension (N)\n*          On input, WERR( IFIRST-OFFSET ) through WERR( ILAST-OFFSET ) are\n*          the errors in the estimates of the corresponding elements in W.\n*          On output, these errors are refined.\n*\n*  WORK    (workspace) DOUBLE PRECISION array, dimension (2*N)\n*          Workspace.\n*\n*  IWORK   (workspace) INTEGER array, dimension (2*N)\n*          Workspace.\n*\n*  PIVMIN  (input) DOUBLE PRECISION\n*          The minimum pivot in the Sturm sequence.\n*\n*  SPDIAM  (input) DOUBLE PRECISION\n*          The spectral diameter of the matrix.\n*\n*  TWIST   (input) INTEGER\n*          The twist index for the twisted factorization that is used\n*          for the negcount.\n*          TWIST = N: Compute negcount from L D L^T - LAMBDA I = L+ D+ L+^T\n*          TWIST = 1: Compute negcount from L D L^T - LAMBDA I = U- D- U-^T\n*          TWIST = R: Compute negcount from L D L^T - LAMBDA I = N(r) D(r) N(r)\n*\n*  INFO    (output) INTEGER\n*          Error flag.\n*\n\n*  Further Details\n*  ===============\n*\n*  Based on contributions by\n*     Beresford Parlett, University of California, Berkeley, USA\n*     Jim Demmel, University of California, Berkeley, USA\n*     Inderjit Dhillon, University of Texas, Austin, USA\n*     Osni Marques, LBNL/NERSC, USA\n*     Christof Voemel, University of California, Berkeley, USA\n*\n*  =====================================================================\n*\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  info, w, wgap, werr = NumRu::Lapack.dlarrb( d, lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, pivmin, spdiam, twist, [:usage => usage, :help => help])\n");
+      return Qnil;
+    } 
+  } else
+    rblapack_options = Qnil;
+  if (argc != 13 && argc != 13)
+    rb_raise(rb_eArgError,"wrong number of arguments (%d for 13)", argc);
+  rblapack_d = argv[0];
+  rblapack_lld = argv[1];
+  rblapack_ifirst = argv[2];
+  rblapack_ilast = argv[3];
+  rblapack_rtol1 = argv[4];
+  rblapack_rtol2 = argv[5];
+  rblapack_offset = argv[6];
+  rblapack_w = argv[7];
+  rblapack_wgap = argv[8];
+  rblapack_werr = argv[9];
+  rblapack_pivmin = argv[10];
+  rblapack_spdiam = argv[11];
+  rblapack_twist = argv[12];
+  if (argc == 13) {
+  } 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*);
+  ifirst = NUM2INT(rblapack_ifirst);
+  rtol1 = NUM2DBL(rblapack_rtol1);
+  offset = NUM2INT(rblapack_offset);
+  if (!NA_IsNArray(rblapack_werr))
+    rb_raise(rb_eArgError, "werr (10th argument) must be NArray");
+  if (NA_RANK(rblapack_werr) != 1)
+    rb_raise(rb_eArgError, "rank of werr (10th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_werr) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of werr must be the same as shape 0 of d");
+  if (NA_TYPE(rblapack_werr) != NA_DFLOAT)
+    rblapack_werr = na_change_type(rblapack_werr, NA_DFLOAT);
+  werr = NA_PTR_TYPE(rblapack_werr, doublereal*);
+  spdiam = NUM2DBL(rblapack_spdiam);
+  ilast = NUM2INT(rblapack_ilast);
+  if (!NA_IsNArray(rblapack_w))
+    rb_raise(rb_eArgError, "w (8th argument) must be NArray");
+  if (NA_RANK(rblapack_w) != 1)
+    rb_raise(rb_eArgError, "rank of w (8th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_w) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of w must be the same as shape 0 of d");
+  if (NA_TYPE(rblapack_w) != NA_DFLOAT)
+    rblapack_w = na_change_type(rblapack_w, NA_DFLOAT);
+  w = NA_PTR_TYPE(rblapack_w, doublereal*);
+  pivmin = NUM2DBL(rblapack_pivmin);
+  if (!NA_IsNArray(rblapack_lld))
+    rb_raise(rb_eArgError, "lld (2th argument) must be NArray");
+  if (NA_RANK(rblapack_lld) != 1)
+    rb_raise(rb_eArgError, "rank of lld (2th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_lld) != (n-1))
+    rb_raise(rb_eRuntimeError, "shape 0 of lld must be %d", n-1);
+  if (NA_TYPE(rblapack_lld) != NA_DFLOAT)
+    rblapack_lld = na_change_type(rblapack_lld, NA_DFLOAT);
+  lld = NA_PTR_TYPE(rblapack_lld, doublereal*);
+  if (!NA_IsNArray(rblapack_wgap))
+    rb_raise(rb_eArgError, "wgap (9th argument) must be NArray");
+  if (NA_RANK(rblapack_wgap) != 1)
+    rb_raise(rb_eArgError, "rank of wgap (9th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_wgap) != (n-1))
+    rb_raise(rb_eRuntimeError, "shape 0 of wgap must be %d", n-1);
+  if (NA_TYPE(rblapack_wgap) != NA_DFLOAT)
+    rblapack_wgap = na_change_type(rblapack_wgap, NA_DFLOAT);
+  wgap = NA_PTR_TYPE(rblapack_wgap, doublereal*);
+  rtol2 = NUM2DBL(rblapack_rtol2);
+  twist = NUM2INT(rblapack_twist);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_w_out__ = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  w_out__ = NA_PTR_TYPE(rblapack_w_out__, doublereal*);
+  MEMCPY(w_out__, w, doublereal, NA_TOTAL(rblapack_w));
+  rblapack_w = rblapack_w_out__;
+  w = w_out__;
+  {
+    na_shape_t shape[1];
+    shape[0] = n-1;
+    rblapack_wgap_out__ = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  wgap_out__ = NA_PTR_TYPE(rblapack_wgap_out__, doublereal*);
+  MEMCPY(wgap_out__, wgap, doublereal, NA_TOTAL(rblapack_wgap));
+  rblapack_wgap = rblapack_wgap_out__;
+  wgap = wgap_out__;
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_werr_out__ = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  werr_out__ = NA_PTR_TYPE(rblapack_werr_out__, doublereal*);
+  MEMCPY(werr_out__, werr, doublereal, NA_TOTAL(rblapack_werr));
+  rblapack_werr = rblapack_werr_out__;
+  werr = werr_out__;
+  work = ALLOC_N(doublereal, (2*n));
+  iwork = ALLOC_N(integer, (2*n));
+
+  dlarrb_(&n, d, lld, &ifirst, &ilast, &rtol1, &rtol2, &offset, w, wgap, werr, work, iwork, &pivmin, &spdiam, &twist, &info);
+
+  free(work);
+  free(iwork);
+  rblapack_info = INT2NUM(info);
+  return rb_ary_new3(4, rblapack_info, rblapack_w, rblapack_wgap, rblapack_werr);
+}
+
+void
+init_lapack_dlarrb(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "dlarrb", rblapack_dlarrb, -1);
+}