ruby-lapack 1.6 → 1.7

data/ext/slartgs.c

@@ -1,62 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slartgs_(real* x, real* y, real* sigma, real* cs, real* sn);
-
-
-static VALUE
-rblapack_slartgs(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_x;
-  real x; 
-  VALUE rblapack_y;
-  real y; 
-  VALUE rblapack_sigma;
-  real sigma; 
-  VALUE rblapack_cs;
-  real cs; 
-  VALUE rblapack_sn;
-  real sn; 
-
-
-  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  cs, sn = NumRu::Lapack.slartgs( x, y, sigma, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLARTGS( X, Y, SIGMA, CS, SN )\n\n*  Purpose\n*  =======\n*\n*  SLARTGS generates a plane rotation designed to introduce a bulge in\n*  Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD\n*  problem. X and Y are the top-row entries, and SIGMA is the shift.\n*  The computed CS and SN define a plane rotation satisfying\n*\n*     [  CS  SN  ]  .  [ X^2 - SIGMA ]  =  [ R ],\n*     [ -SN  CS  ]     [    X * Y    ]     [ 0 ]\n*\n*  with R nonnegative.  If X^2 - SIGMA and X * Y are 0, then the\n*  rotation is by PI/2.\n*\n\n*  Arguments\n*  =========\n*\n*  X       (input) REAL\n*          The (1,1) entry of an upper bidiagonal matrix.\n*\n*  Y       (input) REAL\n*          The (1,2) entry of an upper bidiagonal matrix.\n*\n*  SIGMA   (input) REAL\n*          The shift.\n*\n*  CS      (output) REAL\n*          The cosine of the rotation.\n*\n*  SN      (output) REAL\n*          The sine of the rotation.\n*\n\n*  ===================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  cs, sn = NumRu::Lapack.slartgs( x, y, sigma, [: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_x = argv[0];
-  rblapack_y = argv[1];
-  rblapack_sigma = argv[2];
-  if (argc == 3) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  x = (real)NUM2DBL(rblapack_x);
-  sigma = (real)NUM2DBL(rblapack_sigma);
-  y = (real)NUM2DBL(rblapack_y);
-
-  slartgs_(&x, &y, &sigma, &cs, &sn);
-
-  rblapack_cs = rb_float_new((double)cs);
-  rblapack_sn = rb_float_new((double)sn);
-  return rb_ary_new3(2, rblapack_cs, rblapack_sn);
-}
-
-void
-init_lapack_slartgs(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slartgs", rblapack_slartgs, -1);
-}

data/ext/slartv.c

@@ -1,130 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slartv_(integer* n, real* x, integer* incx, real* y, integer* incy, real* c, real* s, integer* incc);
-
-
-static VALUE
-rblapack_slartv(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_n;
-  integer n; 
-  VALUE rblapack_x;
-  real *x; 
-  VALUE rblapack_incx;
-  integer incx; 
-  VALUE rblapack_y;
-  real *y; 
-  VALUE rblapack_incy;
-  integer incy; 
-  VALUE rblapack_c;
-  real *c; 
-  VALUE rblapack_s;
-  real *s; 
-  VALUE rblapack_incc;
-  integer incc; 
-  VALUE rblapack_x_out__;
-  real *x_out__;
-  VALUE rblapack_y_out__;
-  real *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  x, y = NumRu::Lapack.slartv( n, x, incx, y, incy, c, s, incc, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLARTV( N, X, INCX, Y, INCY, C, S, INCC )\n\n*  Purpose\n*  =======\n*\n*  SLARTV applies a vector of real plane rotations to elements of the\n*  real vectors x and y. For i = 1,2,...,n\n*\n*     ( x(i) ) := (  c(i)  s(i) ) ( x(i) )\n*     ( y(i) )    ( -s(i)  c(i) ) ( y(i) )\n*\n\n*  Arguments\n*  =========\n*\n*  N       (input) INTEGER\n*          The number of plane rotations to be applied.\n*\n*  X       (input/output) REAL array,\n*                         dimension (1+(N-1)*INCX)\n*          The vector x.\n*\n*  INCX    (input) INTEGER\n*          The increment between elements of X. INCX > 0.\n*\n*  Y       (input/output) REAL array,\n*                         dimension (1+(N-1)*INCY)\n*          The vector y.\n*\n*  INCY    (input) INTEGER\n*          The increment between elements of Y. INCY > 0.\n*\n*  C       (input) REAL array, dimension (1+(N-1)*INCC)\n*          The cosines of the plane rotations.\n*\n*  S       (input) REAL array, dimension (1+(N-1)*INCC)\n*          The sines of the plane rotations.\n*\n*  INCC    (input) INTEGER\n*          The increment between elements of C and S. INCC > 0.\n*\n\n*  =====================================================================\n*\n*     .. Local Scalars ..\n      INTEGER            I, IC, IX, IY\n      REAL               XI, YI\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  x, y = NumRu::Lapack.slartv( n, x, incx, y, incy, c, s, incc, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 8 && argc != 8)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 8)", argc);
-  rblapack_n = argv[0];
-  rblapack_x = argv[1];
-  rblapack_incx = argv[2];
-  rblapack_y = argv[3];
-  rblapack_incy = argv[4];
-  rblapack_c = argv[5];
-  rblapack_s = argv[6];
-  rblapack_incc = argv[7];
-  if (argc == 8) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  n = NUM2INT(rblapack_n);
-  incx = NUM2INT(rblapack_incx);
-  incy = NUM2INT(rblapack_incy);
-  incc = NUM2INT(rblapack_incc);
-  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_SFLOAT)
-    rblapack_x = na_change_type(rblapack_x, NA_SFLOAT);
-  x = NA_PTR_TYPE(rblapack_x, real*);
-  if (!NA_IsNArray(rblapack_c))
-    rb_raise(rb_eArgError, "c (6th argument) must be NArray");
-  if (NA_RANK(rblapack_c) != 1)
-    rb_raise(rb_eArgError, "rank of c (6th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_c) != (1+(n-1)*incc))
-    rb_raise(rb_eRuntimeError, "shape 0 of c must be %d", 1+(n-1)*incc);
-  if (NA_TYPE(rblapack_c) != NA_SFLOAT)
-    rblapack_c = na_change_type(rblapack_c, NA_SFLOAT);
-  c = NA_PTR_TYPE(rblapack_c, real*);
-  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_SFLOAT)
-    rblapack_y = na_change_type(rblapack_y, NA_SFLOAT);
-  y = NA_PTR_TYPE(rblapack_y, real*);
-  if (!NA_IsNArray(rblapack_s))
-    rb_raise(rb_eArgError, "s (7th argument) must be NArray");
-  if (NA_RANK(rblapack_s) != 1)
-    rb_raise(rb_eArgError, "rank of s (7th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_s) != (1+(n-1)*incc))
-    rb_raise(rb_eRuntimeError, "shape 0 of s must be %d", 1+(n-1)*incc);
-  if (NA_TYPE(rblapack_s) != NA_SFLOAT)
-    rblapack_s = na_change_type(rblapack_s, NA_SFLOAT);
-  s = NA_PTR_TYPE(rblapack_s, real*);
-  {
-    int shape[1];
-    shape[0] = 1+(n-1)*incx;
-    rblapack_x_out__ = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  x_out__ = NA_PTR_TYPE(rblapack_x_out__, real*);
-  MEMCPY(x_out__, x, real, NA_TOTAL(rblapack_x));
-  rblapack_x = rblapack_x_out__;
-  x = x_out__;
-  {
-    int shape[1];
-    shape[0] = 1+(n-1)*incy;
-    rblapack_y_out__ = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  y_out__ = NA_PTR_TYPE(rblapack_y_out__, real*);
-  MEMCPY(y_out__, y, real, NA_TOTAL(rblapack_y));
-  rblapack_y = rblapack_y_out__;
-  y = y_out__;
-
-  slartv_(&n, x, &incx, y, &incy, c, s, &incc);
-
-  return rb_ary_new3(2, rblapack_x, rblapack_y);
-}
-
-void
-init_lapack_slartv(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slartv", rblapack_slartv, -1);
-}

data/ext/slaruv.c

@@ -1,79 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slaruv_(integer* iseed, integer* n, real* x);
-
-
-static VALUE
-rblapack_slaruv(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_iseed;
-  integer *iseed; 
-  VALUE rblapack_n;
-  integer n; 
-  VALUE rblapack_x;
-  real *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.slaruv( iseed, n, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLARUV( ISEED, N, X )\n\n*  Purpose\n*  =======\n*\n*  SLARUV returns a vector of n random real numbers from a uniform (0,1)\n*  distribution (n <= 128).\n*\n*  This is an auxiliary routine called by SLARNV and CLARNV.\n*\n\n*  Arguments\n*  =========\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 <= 128.\n*\n*  X       (output) REAL array, dimension (N)\n*          The generated random numbers.\n*\n\n*  Further Details\n*  ===============\n*\n*  This routine uses a multiplicative congruential method with modulus\n*  2**48 and multiplier 33952834046453 (see G.S.Fishman,\n*  'Multiplicative congruential random number generators with modulus\n*  2**b: an exhaustive analysis for b = 32 and a partial analysis for\n*  b = 48', Math. Comp. 189, pp 331-344, 1990).\n*\n*  48-bit integers are stored in 4 integer array elements with 12 bits\n*  per element. Hence the routine is portable across machines with\n*  integers of 32 bits or more.\n*\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  x, iseed = NumRu::Lapack.slaruv( iseed, n, [: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_iseed = argv[0];
-  rblapack_n = argv[1];
-  if (argc == 2) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  if (!NA_IsNArray(rblapack_iseed))
-    rb_raise(rb_eArgError, "iseed (1th argument) must be NArray");
-  if (NA_RANK(rblapack_iseed) != 1)
-    rb_raise(rb_eArgError, "rank of iseed (1th 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*);
-  n = NUM2INT(rblapack_n);
-  {
-    int shape[1];
-    shape[0] = MAX(1,n);
-    rblapack_x = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  x = NA_PTR_TYPE(rblapack_x, real*);
-  {
-    int 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__;
-
-  slaruv_(iseed, &n, x);
-
-  return rb_ary_new3(2, rblapack_x, rblapack_iseed);
-}
-
-void
-init_lapack_slaruv(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slaruv", rblapack_slaruv, -1);
-}

data/ext/slarz.c

@@ -1,105 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slarz_(char* side, integer* m, integer* n, integer* l, real* v, integer* incv, real* tau, real* c, integer* ldc, real* work);
-
-
-static VALUE
-rblapack_slarz(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_side;
-  char side; 
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_l;
-  integer l; 
-  VALUE rblapack_v;
-  real *v; 
-  VALUE rblapack_incv;
-  integer incv; 
-  VALUE rblapack_tau;
-  real tau; 
-  VALUE rblapack_c;
-  real *c; 
-  VALUE rblapack_c_out__;
-  real *c_out__;
-  real *work;
-
-  integer ldc;
-  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  c = NumRu::Lapack.slarz( side, m, l, v, incv, tau, c, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLARZ( SIDE, M, N, L, V, INCV, TAU, C, LDC, WORK )\n\n*  Purpose\n*  =======\n*\n*  SLARZ applies a real elementary reflector H to a real M-by-N\n*  matrix C, from either the left or the right. H is represented in the\n*  form\n*\n*        H = I - tau * v * v'\n*\n*  where tau is a real scalar and v is a real vector.\n*\n*  If tau = 0, then H is taken to be the unit matrix.\n*\n*\n*  H is a product of k elementary reflectors as returned by STZRZF.\n*\n\n*  Arguments\n*  =========\n*\n*  SIDE    (input) CHARACTER*1\n*          = 'L': form  H * C\n*          = 'R': form  C * H\n*\n*  M       (input) INTEGER\n*          The number of rows of the matrix C.\n*\n*  N       (input) INTEGER\n*          The number of columns of the matrix C.\n*\n*  L       (input) INTEGER\n*          The number of entries of the vector V containing\n*          the meaningful part of the Householder vectors.\n*          If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0.\n*\n*  V       (input) REAL array, dimension (1+(L-1)*abs(INCV))\n*          The vector v in the representation of H as returned by\n*          STZRZF. V is not used if TAU = 0.\n*\n*  INCV    (input) INTEGER\n*          The increment between elements of v. INCV <> 0.\n*\n*  TAU     (input) REAL\n*          The value tau in the representation of H.\n*\n*  C       (input/output) REAL array, dimension (LDC,N)\n*          On entry, the M-by-N matrix C.\n*          On exit, C is overwritten by the matrix H * C if SIDE = 'L',\n*          or C * H if SIDE = 'R'.\n*\n*  LDC     (input) INTEGER\n*          The leading dimension of the array C. LDC >= max(1,M).\n*\n*  WORK    (workspace) REAL array, dimension\n*                         (N) if SIDE = 'L'\n*                      or (M) if SIDE = 'R'\n*\n\n*  Further Details\n*  ===============\n*\n*  Based on contributions by\n*    A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA\n*\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  c = NumRu::Lapack.slarz( side, m, l, v, incv, tau, c, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 7 && argc != 7)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 7)", argc);
-  rblapack_side = argv[0];
-  rblapack_m = argv[1];
-  rblapack_l = argv[2];
-  rblapack_v = argv[3];
-  rblapack_incv = argv[4];
-  rblapack_tau = argv[5];
-  rblapack_c = argv[6];
-  if (argc == 7) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  side = StringValueCStr(rblapack_side)[0];
-  l = NUM2INT(rblapack_l);
-  incv = NUM2INT(rblapack_incv);
-  if (!NA_IsNArray(rblapack_c))
-    rb_raise(rb_eArgError, "c (7th argument) must be NArray");
-  if (NA_RANK(rblapack_c) != 2)
-    rb_raise(rb_eArgError, "rank of c (7th argument) must be %d", 2);
-  ldc = NA_SHAPE0(rblapack_c);
-  n = NA_SHAPE1(rblapack_c);
-  if (NA_TYPE(rblapack_c) != NA_SFLOAT)
-    rblapack_c = na_change_type(rblapack_c, NA_SFLOAT);
-  c = NA_PTR_TYPE(rblapack_c, real*);
-  m = NUM2INT(rblapack_m);
-  tau = (real)NUM2DBL(rblapack_tau);
-  if (!NA_IsNArray(rblapack_v))
-    rb_raise(rb_eArgError, "v (4th argument) must be NArray");
-  if (NA_RANK(rblapack_v) != 1)
-    rb_raise(rb_eArgError, "rank of v (4th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_v) != (1+(l-1)*abs(incv)))
-    rb_raise(rb_eRuntimeError, "shape 0 of v must be %d", 1+(l-1)*abs(incv));
-  if (NA_TYPE(rblapack_v) != NA_SFLOAT)
-    rblapack_v = na_change_type(rblapack_v, NA_SFLOAT);
-  v = NA_PTR_TYPE(rblapack_v, real*);
-  {
-    int shape[2];
-    shape[0] = ldc;
-    shape[1] = n;
-    rblapack_c_out__ = na_make_object(NA_SFLOAT, 2, shape, cNArray);
-  }
-  c_out__ = NA_PTR_TYPE(rblapack_c_out__, real*);
-  MEMCPY(c_out__, c, real, NA_TOTAL(rblapack_c));
-  rblapack_c = rblapack_c_out__;
-  c = c_out__;
-  work = ALLOC_N(real, (lsame_(&side,"L") ? n : lsame_(&side,"R") ? m : 0));
-
-  slarz_(&side, &m, &n, &l, v, &incv, &tau, c, &ldc, work);
-
-  free(work);
-  return rblapack_c;
-}
-
-void
-init_lapack_slarz(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slarz", rblapack_slarz, -1);
-}

data/ext/slarzb.c

@@ -1,127 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slarzb_(char* side, char* trans, char* direct, char* storev, integer* m, integer* n, integer* k, integer* l, real* v, integer* ldv, real* t, integer* ldt, real* c, integer* ldc, real* work, integer* ldwork);
-
-
-static VALUE
-rblapack_slarzb(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_side;
-  char side; 
-  VALUE rblapack_trans;
-  char trans; 
-  VALUE rblapack_direct;
-  char direct; 
-  VALUE rblapack_storev;
-  char storev; 
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_l;
-  integer l; 
-  VALUE rblapack_v;
-  real *v; 
-  VALUE rblapack_t;
-  real *t; 
-  VALUE rblapack_c;
-  real *c; 
-  VALUE rblapack_c_out__;
-  real *c_out__;
-  real *work;
-
-  integer ldv;
-  integer nv;
-  integer ldt;
-  integer k;
-  integer ldc;
-  integer n;
-  integer ldwork;
-
-  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 = NumRu::Lapack.slarzb( side, trans, direct, storev, m, l, v, t, c, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLARZB( SIDE, TRANS, DIRECT, STOREV, M, N, K, L, V, LDV, T, LDT, C, LDC, WORK, LDWORK )\n\n*  Purpose\n*  =======\n*\n*  SLARZB applies a real block reflector H or its transpose H**T to\n*  a real distributed M-by-N  C from the left or the right.\n*\n*  Currently, only STOREV = 'R' and DIRECT = 'B' are supported.\n*\n\n*  Arguments\n*  =========\n*\n*  SIDE    (input) CHARACTER*1\n*          = 'L': apply H or H' from the Left\n*          = 'R': apply H or H' from the Right\n*\n*  TRANS   (input) CHARACTER*1\n*          = 'N': apply H (No transpose)\n*          = 'C': apply H' (Transpose)\n*\n*  DIRECT  (input) CHARACTER*1\n*          Indicates how H is formed from a product of elementary\n*          reflectors\n*          = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)\n*          = 'B': H = H(k) . . . H(2) H(1) (Backward)\n*\n*  STOREV  (input) CHARACTER*1\n*          Indicates how the vectors which define the elementary\n*          reflectors are stored:\n*          = 'C': Columnwise                        (not supported yet)\n*          = 'R': Rowwise\n*\n*  M       (input) INTEGER\n*          The number of rows of the matrix C.\n*\n*  N       (input) INTEGER\n*          The number of columns of the matrix C.\n*\n*  K       (input) INTEGER\n*          The order of the matrix T (= the number of elementary\n*          reflectors whose product defines the block reflector).\n*\n*  L       (input) INTEGER\n*          The number of columns of the matrix V containing the\n*          meaningful part of the Householder reflectors.\n*          If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0.\n*\n*  V       (input) REAL array, dimension (LDV,NV).\n*          If STOREV = 'C', NV = K; if STOREV = 'R', NV = L.\n*\n*  LDV     (input) INTEGER\n*          The leading dimension of the array V.\n*          If STOREV = 'C', LDV >= L; if STOREV = 'R', LDV >= K.\n*\n*  T       (input) REAL array, dimension (LDT,K)\n*          The triangular K-by-K matrix T in the representation of the\n*          block reflector.\n*\n*  LDT     (input) INTEGER\n*          The leading dimension of the array T. LDT >= K.\n*\n*  C       (input/output) REAL array, dimension (LDC,N)\n*          On entry, the M-by-N matrix C.\n*          On exit, C is overwritten by H*C or H'*C or C*H or C*H'.\n*\n*  LDC     (input) INTEGER\n*          The leading dimension of the array C. LDC >= max(1,M).\n*\n*  WORK    (workspace) REAL array, dimension (LDWORK,K)\n*\n*  LDWORK  (input) INTEGER\n*          The leading dimension of the array WORK.\n*          If SIDE = 'L', LDWORK >= max(1,N);\n*          if SIDE = 'R', LDWORK >= max(1,M).\n*\n\n*  Further Details\n*  ===============\n*\n*  Based on contributions by\n*    A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA\n*\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  c = NumRu::Lapack.slarzb( side, trans, direct, storev, m, l, v, t, c, [: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_side = argv[0];
-  rblapack_trans = argv[1];
-  rblapack_direct = argv[2];
-  rblapack_storev = argv[3];
-  rblapack_m = argv[4];
-  rblapack_l = argv[5];
-  rblapack_v = argv[6];
-  rblapack_t = argv[7];
-  rblapack_c = argv[8];
-  if (argc == 9) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  side = StringValueCStr(rblapack_side)[0];
-  direct = StringValueCStr(rblapack_direct)[0];
-  m = NUM2INT(rblapack_m);
-  if (!NA_IsNArray(rblapack_v))
-    rb_raise(rb_eArgError, "v (7th argument) must be NArray");
-  if (NA_RANK(rblapack_v) != 2)
-    rb_raise(rb_eArgError, "rank of v (7th argument) must be %d", 2);
-  ldv = NA_SHAPE0(rblapack_v);
-  nv = NA_SHAPE1(rblapack_v);
-  if (NA_TYPE(rblapack_v) != NA_SFLOAT)
-    rblapack_v = na_change_type(rblapack_v, NA_SFLOAT);
-  v = NA_PTR_TYPE(rblapack_v, real*);
-  if (!NA_IsNArray(rblapack_c))
-    rb_raise(rb_eArgError, "c (9th argument) must be NArray");
-  if (NA_RANK(rblapack_c) != 2)
-    rb_raise(rb_eArgError, "rank of c (9th argument) must be %d", 2);
-  ldc = NA_SHAPE0(rblapack_c);
-  n = NA_SHAPE1(rblapack_c);
-  if (NA_TYPE(rblapack_c) != NA_SFLOAT)
-    rblapack_c = na_change_type(rblapack_c, NA_SFLOAT);
-  c = NA_PTR_TYPE(rblapack_c, real*);
-  trans = StringValueCStr(rblapack_trans)[0];
-  l = NUM2INT(rblapack_l);
-  ldwork = MAX(1,n) ? side = 'l' : MAX(1,m) ? side = 'r' : 0;
-  storev = StringValueCStr(rblapack_storev)[0];
-  if (!NA_IsNArray(rblapack_t))
-    rb_raise(rb_eArgError, "t (8th argument) must be NArray");
-  if (NA_RANK(rblapack_t) != 2)
-    rb_raise(rb_eArgError, "rank of t (8th argument) must be %d", 2);
-  ldt = NA_SHAPE0(rblapack_t);
-  k = NA_SHAPE1(rblapack_t);
-  if (NA_TYPE(rblapack_t) != NA_SFLOAT)
-    rblapack_t = na_change_type(rblapack_t, NA_SFLOAT);
-  t = NA_PTR_TYPE(rblapack_t, real*);
-  {
-    int shape[2];
-    shape[0] = ldc;
-    shape[1] = n;
-    rblapack_c_out__ = na_make_object(NA_SFLOAT, 2, shape, cNArray);
-  }
-  c_out__ = NA_PTR_TYPE(rblapack_c_out__, real*);
-  MEMCPY(c_out__, c, real, NA_TOTAL(rblapack_c));
-  rblapack_c = rblapack_c_out__;
-  c = c_out__;
-  work = ALLOC_N(real, (ldwork)*(k));
-
-  slarzb_(&side, &trans, &direct, &storev, &m, &n, &k, &l, v, &ldv, t, &ldt, c, &ldc, work, &ldwork);
-
-  free(work);
-  return rblapack_c;
-}
-
-void
-init_lapack_slarzb(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slarzb", rblapack_slarzb, -1);
-}