ruby-lapack 1.6 → 1.7

data/ext/dzsum1.c

@@ -1,63 +0,0 @@
-#include "rb_lapack.h"
-
-extern doublereal dzsum1_(integer* n, doublecomplex* cx, integer* incx);
-
-
-static VALUE
-rblapack_dzsum1(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_cx;
-  doublecomplex *cx; 
-  VALUE rblapack_incx;
-  integer incx; 
-  VALUE rblapack___out__;
-  doublereal __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  __out__ = NumRu::Lapack.dzsum1( cx, incx, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      DOUBLE PRECISION FUNCTION DZSUM1( N, CX, INCX )\n\n*  Purpose\n*  =======\n*\n*  DZSUM1 takes the sum of the absolute values of a complex\n*  vector and returns a double precision result.\n*\n*  Based on DZASUM from the Level 1 BLAS.\n*  The change is to use the 'genuine' absolute value.\n*\n*  Contributed by Nick Higham for use with ZLACON.\n*\n\n*  Arguments\n*  =========\n*\n*  N       (input) INTEGER\n*          The number of elements in the vector CX.\n*\n*  CX      (input) COMPLEX*16 array, dimension (N)\n*          The vector whose elements will be summed.\n*\n*  INCX    (input) INTEGER\n*          The spacing between successive values of CX.  INCX > 0.\n*\n\n*  =====================================================================\n*\n*     .. Local Scalars ..\n      INTEGER            I, NINCX\n      DOUBLE PRECISION   STEMP\n*     ..\n*     .. Intrinsic Functions ..\n      INTRINSIC          ABS\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.dzsum1( cx, incx, [: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_cx = argv[0];
-  rblapack_incx = argv[1];
-  if (argc == 2) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  if (!NA_IsNArray(rblapack_cx))
-    rb_raise(rb_eArgError, "cx (1th argument) must be NArray");
-  if (NA_RANK(rblapack_cx) != 1)
-    rb_raise(rb_eArgError, "rank of cx (1th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_cx);
-  if (NA_TYPE(rblapack_cx) != NA_DCOMPLEX)
-    rblapack_cx = na_change_type(rblapack_cx, NA_DCOMPLEX);
-  cx = NA_PTR_TYPE(rblapack_cx, doublecomplex*);
-  incx = NUM2INT(rblapack_incx);
-
-  __out__ = dzsum1_(&n, cx, &incx);
-
-  rblapack___out__ = rb_float_new((double)__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_dzsum1(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "dzsum1", rblapack_dzsum1, -1);
-}

data/ext/icmax1.c

@@ -1,63 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer icmax1_(integer* n, complex* cx, integer* incx);
-
-
-static VALUE
-rblapack_icmax1(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_cx;
-  complex *cx; 
-  VALUE rblapack_incx;
-  integer incx; 
-  VALUE rblapack___out__;
-  integer __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  __out__ = NumRu::Lapack.icmax1( cx, incx, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER          FUNCTION ICMAX1( N, CX, INCX )\n\n*  Purpose\n*  =======\n*\n*  ICMAX1 finds the index of the element whose real part has maximum\n*  absolute value.\n*\n*  Based on ICAMAX from Level 1 BLAS.\n*  The change is to use the 'genuine' absolute value.\n*\n*  Contributed by Nick Higham for use with CLACON.\n*\n\n*  Arguments\n*  =========\n*\n*  N       (input) INTEGER\n*          The number of elements in the vector CX.\n*\n*  CX      (input) COMPLEX array, dimension (N)\n*          The vector whose elements will be summed.\n*\n*  INCX    (input) INTEGER\n*          The spacing between successive values of CX.  INCX >= 1.\n*\n\n* =====================================================================\n*\n*     .. Local Scalars ..\n      INTEGER            I, IX\n      REAL               SMAX\n      COMPLEX            ZDUM\n*     ..\n*     .. Intrinsic Functions ..\n      INTRINSIC          ABS\n*     ..\n*     .. Statement Functions ..\n      REAL               CABS1\n*     ..\n*     .. Statement Function definitions ..\n*\n*     NEXT LINE IS THE ONLY MODIFICATION.\n      CABS1( ZDUM ) = ABS( ZDUM )\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.icmax1( cx, incx, [: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_cx = argv[0];
-  rblapack_incx = argv[1];
-  if (argc == 2) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  if (!NA_IsNArray(rblapack_cx))
-    rb_raise(rb_eArgError, "cx (1th argument) must be NArray");
-  if (NA_RANK(rblapack_cx) != 1)
-    rb_raise(rb_eArgError, "rank of cx (1th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_cx);
-  if (NA_TYPE(rblapack_cx) != NA_SCOMPLEX)
-    rblapack_cx = na_change_type(rblapack_cx, NA_SCOMPLEX);
-  cx = NA_PTR_TYPE(rblapack_cx, complex*);
-  incx = NUM2INT(rblapack_incx);
-
-  __out__ = icmax1_(&n, cx, &incx);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_icmax1(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "icmax1", rblapack_icmax1, -1);
-}

data/ext/ieeeck.c

@@ -1,59 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer ieeeck_(integer* ispec, real* zero, real* one);
-
-
-static VALUE
-rblapack_ieeeck(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_ispec;
-  integer ispec; 
-  VALUE rblapack_zero;
-  real zero; 
-  VALUE rblapack_one;
-  real one; 
-  VALUE rblapack___out__;
-  integer __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  __out__ = NumRu::Lapack.ieeeck( ispec, zero, one, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER          FUNCTION IEEECK( ISPEC, ZERO, ONE )\n\n*  Purpose\n*  =======\n*\n*  IEEECK is called from the ILAENV to verify that Infinity and\n*  possibly NaN arithmetic is safe (i.e. will not trap).\n*\n\n*  Arguments\n*  =========\n*\n*  ISPEC   (input) INTEGER\n*          Specifies whether to test just for inifinity arithmetic\n*          or whether to test for infinity and NaN arithmetic.\n*          = 0: Verify infinity arithmetic only.\n*          = 1: Verify infinity and NaN arithmetic.\n*\n*  ZERO    (input) REAL\n*          Must contain the value 0.0\n*          This is passed to prevent the compiler from optimizing\n*          away this code.\n*\n*  ONE     (input) REAL\n*          Must contain the value 1.0\n*          This is passed to prevent the compiler from optimizing\n*          away this code.\n*\n*  RETURN VALUE:  INTEGER\n*          = 0:  Arithmetic failed to produce the correct answers\n*          = 1:  Arithmetic produced the correct answers\n*\n*     .. Local Scalars ..\n      REAL               NAN1, NAN2, NAN3, NAN4, NAN5, NAN6, NEGINF,\n     $                   NEGZRO, NEWZRO, POSINF\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.ieeeck( ispec, zero, one, [: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_ispec = argv[0];
-  rblapack_zero = argv[1];
-  rblapack_one = argv[2];
-  if (argc == 3) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  ispec = NUM2INT(rblapack_ispec);
-  one = (real)NUM2DBL(rblapack_one);
-  zero = (real)NUM2DBL(rblapack_zero);
-
-  __out__ = ieeeck_(&ispec, &zero, &one);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_ieeeck(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "ieeeck", rblapack_ieeeck, -1);
-}

data/ext/ilaclc.c

@@ -1,65 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer ilaclc_(integer* m, integer* n, complex* a, integer* lda);
-
-
-static VALUE
-rblapack_ilaclc(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_a;
-  complex *a; 
-  VALUE rblapack___out__;
-  integer __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  __out__ = NumRu::Lapack.ilaclc( m, a, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER FUNCTION ILACLC( M, N, A, LDA )\n\n*  Purpose\n*  =======\n*\n*  ILACLC scans A for its last non-zero column.\n*\n\n*  Arguments\n*  =========\n*\n*  M       (input) INTEGER\n*          The number of rows of the matrix A.\n*\n*  N       (input) INTEGER\n*          The number of columns of the matrix A.\n*\n*  A       (input) COMPLEX array, dimension (LDA,N)\n*          The m by n matrix A.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A. LDA >= max(1,M).\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.ilaclc( m, a, [: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_m = argv[0];
-  rblapack_a = argv[1];
-  if (argc == 2) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  m = NUM2INT(rblapack_m);
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (2th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (2th argument) must be %d", 2);
-  lda = NA_SHAPE0(rblapack_a);
-  n = NA_SHAPE1(rblapack_a);
-  if (NA_TYPE(rblapack_a) != NA_SCOMPLEX)
-    rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
-  a = NA_PTR_TYPE(rblapack_a, complex*);
-
-  __out__ = ilaclc_(&m, &n, a, &lda);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_ilaclc(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "ilaclc", rblapack_ilaclc, -1);
-}

data/ext/ilaclr.c

@@ -1,65 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer ilaclr_(integer* m, integer* n, complex* a, integer* lda);
-
-
-static VALUE
-rblapack_ilaclr(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_a;
-  complex *a; 
-  VALUE rblapack___out__;
-  integer __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  __out__ = NumRu::Lapack.ilaclr( m, a, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER FUNCTION ILACLR( M, N, A, LDA )\n\n*  Purpose\n*  =======\n*\n*  ILACLR scans A for its last non-zero row.\n*\n\n*  Arguments\n*  =========\n*\n*  M       (input) INTEGER\n*          The number of rows of the matrix A.\n*\n*  N       (input) INTEGER\n*          The number of columns of the matrix A.\n*\n*  A       (input) COMPLEX          array, dimension (LDA,N)\n*          The m by n matrix A.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A. LDA >= max(1,M).\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.ilaclr( m, a, [: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_m = argv[0];
-  rblapack_a = argv[1];
-  if (argc == 2) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  m = NUM2INT(rblapack_m);
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (2th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (2th argument) must be %d", 2);
-  lda = NA_SHAPE0(rblapack_a);
-  n = NA_SHAPE1(rblapack_a);
-  if (NA_TYPE(rblapack_a) != NA_SCOMPLEX)
-    rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
-  a = NA_PTR_TYPE(rblapack_a, complex*);
-
-  __out__ = ilaclr_(&m, &n, a, &lda);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_ilaclr(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "ilaclr", rblapack_ilaclr, -1);
-}

data/ext/iladiag.c

@@ -1,51 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer iladiag_(char* diag);
-
-
-static VALUE
-rblapack_iladiag(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_diag;
-  char diag; 
-  VALUE rblapack___out__;
-  integer __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  __out__ = NumRu::Lapack.iladiag( diag, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER FUNCTION ILADIAG( DIAG )\n\n*  Purpose\n*  =======\n*\n*  This subroutine translated from a character string specifying if a\n*  matrix has unit diagonal or not to the relevant BLAST-specified\n*  integer constant.\n*\n*  ILADIAG returns an INTEGER.  If ILADIAG < 0, then the input is not a\n*  character indicating a unit or non-unit diagonal.  Otherwise ILADIAG\n*  returns the constant value corresponding to DIAG.\n*\n\n*  Arguments\n*  =========\n*  DIAG    (input) CHARACTER*1\n*          = 'N':  A is non-unit triangular;\n*          = 'U':  A is unit triangular.\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.iladiag( diag, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 1 && argc != 1)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 1)", argc);
-  rblapack_diag = argv[0];
-  if (argc == 1) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  diag = StringValueCStr(rblapack_diag)[0];
-
-  __out__ = iladiag_(&diag);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_iladiag(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "iladiag", rblapack_iladiag, -1);
-}

data/ext/iladlc.c

@@ -1,65 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer iladlc_(integer* m, integer* n, doublereal* a, integer* lda);
-
-
-static VALUE
-rblapack_iladlc(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_a;
-  doublereal *a; 
-  VALUE rblapack___out__;
-  integer __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  __out__ = NumRu::Lapack.iladlc( m, a, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER FUNCTION ILADLC( M, N, A, LDA )\n\n*  Purpose\n*  =======\n*\n*  ILADLC scans A for its last non-zero column.\n*\n\n*  Arguments\n*  =========\n*\n*  M       (input) INTEGER\n*          The number of rows of the matrix A.\n*\n*  N       (input) INTEGER\n*          The number of columns of the matrix A.\n*\n*  A       (input) DOUBLE PRECISION array, dimension (LDA,N)\n*          The m by n matrix A.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A. LDA >= max(1,M).\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.iladlc( m, a, [: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_m = argv[0];
-  rblapack_a = argv[1];
-  if (argc == 2) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  m = NUM2INT(rblapack_m);
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (2th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (2th 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*);
-
-  __out__ = iladlc_(&m, &n, a, &lda);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_iladlc(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "iladlc", rblapack_iladlc, -1);
-}

data/ext/iladlr.c

@@ -1,65 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer iladlr_(integer* m, integer* n, doublereal* a, integer* lda);
-
-
-static VALUE
-rblapack_iladlr(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_a;
-  doublereal *a; 
-  VALUE rblapack___out__;
-  integer __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  __out__ = NumRu::Lapack.iladlr( m, a, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER FUNCTION ILADLR( M, N, A, LDA )\n\n*  Purpose\n*  =======\n*\n*  ILADLR scans A for its last non-zero row.\n*\n\n*  Arguments\n*  =========\n*\n*  M       (input) INTEGER\n*          The number of rows of the matrix A.\n*\n*  N       (input) INTEGER\n*          The number of columns of the matrix A.\n*\n*  A       (input) DOUBLE PRECISION array, dimension (LDA,N)\n*          The m by n matrix A.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A. LDA >= max(1,M).\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.iladlr( m, a, [: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_m = argv[0];
-  rblapack_a = argv[1];
-  if (argc == 2) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  m = NUM2INT(rblapack_m);
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (2th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (2th 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*);
-
-  __out__ = iladlr_(&m, &n, a, &lda);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_iladlr(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "iladlr", rblapack_iladlr, -1);
-}