ruby-lapack 1.6 → 1.7

data/ext/ilaenv.c

@@ -1,75 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer ilaenv_(integer* ispec, char* name, char* opts, integer* n1, integer* n2, integer* n3, integer* n4);
-
-
-static VALUE
-rblapack_ilaenv(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_ispec;
-  integer ispec; 
-  VALUE rblapack_name;
-  char *name; 
-  VALUE rblapack_opts;
-  char *opts; 
-  VALUE rblapack_n1;
-  integer n1; 
-  VALUE rblapack_n2;
-  integer n2; 
-  VALUE rblapack_n3;
-  integer n3; 
-  VALUE rblapack_n4;
-  integer n4; 
-  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.ilaenv( ispec, name, opts, n1, n2, n3, n4, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER FUNCTION ILAENV( ISPEC, NAME, OPTS, N1, N2, N3, N4 )\n\n*  Purpose\n*  =======\n*\n*  ILAENV is called from the LAPACK routines to choose problem-dependent\n*  parameters for the local environment.  See ISPEC for a description of\n*  the parameters.\n*\n*  ILAENV returns an INTEGER\n*  if ILAENV >= 0: ILAENV returns the value of the parameter specified by ISPEC\n*  if ILAENV < 0:  if ILAENV = -k, the k-th argument had an illegal value.\n*\n*  This version provides a set of parameters which should give good,\n*  but not optimal, performance on many of the currently available\n*  computers.  Users are encouraged to modify this subroutine to set\n*  the tuning parameters for their particular machine using the option\n*  and problem size information in the arguments.\n*\n*  This routine will not function correctly if it is converted to all\n*  lower case.  Converting it to all upper case is allowed.\n*\n\n*  Arguments\n*  =========\n*\n*  ISPEC   (input) INTEGER\n*          Specifies the parameter to be returned as the value of\n*          ILAENV.\n*          = 1: the optimal blocksize; if this value is 1, an unblocked\n*               algorithm will give the best performance.\n*          = 2: the minimum block size for which the block routine\n*               should be used; if the usable block size is less than\n*               this value, an unblocked routine should be used.\n*          = 3: the crossover point (in a block routine, for N less\n*               than this value, an unblocked routine should be used)\n*          = 4: the number of shifts, used in the nonsymmetric\n*               eigenvalue routines (DEPRECATED)\n*          = 5: the minimum column dimension for blocking to be used;\n*               rectangular blocks must have dimension at least k by m,\n*               where k is given by ILAENV(2,...) and m by ILAENV(5,...)\n*          = 6: the crossover point for the SVD (when reducing an m by n\n*               matrix to bidiagonal form, if max(m,n)/min(m,n) exceeds\n*               this value, a QR factorization is used first to reduce\n*               the matrix to a triangular form.)\n*          = 7: the number of processors\n*          = 8: the crossover point for the multishift QR method\n*               for nonsymmetric eigenvalue problems (DEPRECATED)\n*          = 9: maximum size of the subproblems at the bottom of the\n*               computation tree in the divide-and-conquer algorithm\n*               (used by xGELSD and xGESDD)\n*          =10: ieee NaN arithmetic can be trusted not to trap\n*          =11: infinity arithmetic can be trusted not to trap\n*          12 <= ISPEC <= 16:\n*               xHSEQR or one of its subroutines,\n*               see IPARMQ for detailed explanation\n*\n*  NAME    (input) CHARACTER*(*)\n*          The name of the calling subroutine, in either upper case or\n*          lower case.\n*\n*  OPTS    (input) CHARACTER*(*)\n*          The character options to the subroutine NAME, concatenated\n*          into a single character string.  For example, UPLO = 'U',\n*          TRANS = 'T', and DIAG = 'N' for a triangular routine would\n*          be specified as OPTS = 'UTN'.\n*\n*  N1      (input) INTEGER\n*  N2      (input) INTEGER\n*  N3      (input) INTEGER\n*  N4      (input) INTEGER\n*          Problem dimensions for the subroutine NAME; these may not all\n*          be required.\n*\n\n*  Further Details\n*  ===============\n*\n*  The following conventions have been used when calling ILAENV from the\n*  LAPACK routines:\n*  1)  OPTS is a concatenation of all of the character options to\n*      subroutine NAME, in the same order that they appear in the\n*      argument list for NAME, even if they are not used in determining\n*      the value of the parameter specified by ISPEC.\n*  2)  The problem dimensions N1, N2, N3, N4 are specified in the order\n*      that they appear in the argument list for NAME.  N1 is used\n*      first, N2 second, and so on, and unused problem dimensions are\n*      passed a value of -1.\n*  3)  The parameter value returned by ILAENV is checked for validity in\n*      the calling subroutine.  For example, ILAENV is used to retrieve\n*      the optimal blocksize for STRTRI as follows:\n*\n*      NB = ILAENV( 1, 'STRTRI', UPLO // DIAG, N, -1, -1, -1 )\n*      IF( NB.LE.1 ) NB = MAX( 1, N )\n*\n*  =====================================================================\n*\n*     .. Local Scalars ..\n      INTEGER            I, IC, IZ, NB, NBMIN, NX\n      LOGICAL            CNAME, SNAME\n      CHARACTER          C1*1, C2*2, C4*2, C3*3, SUBNAM*6\n*     ..\n*     .. Intrinsic Functions ..\n      INTRINSIC          CHAR, ICHAR, INT, MIN, REAL\n*     ..\n*     .. External Functions ..\n      INTEGER            IEEECK, IPARMQ\n      EXTERNAL           IEEECK, IPARMQ\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.ilaenv( ispec, name, opts, n1, n2, n3, n4, [: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_ispec = argv[0];
-  rblapack_name = argv[1];
-  rblapack_opts = argv[2];
-  rblapack_n1 = argv[3];
-  rblapack_n2 = argv[4];
-  rblapack_n3 = argv[5];
-  rblapack_n4 = argv[6];
-  if (argc == 7) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  ispec = NUM2INT(rblapack_ispec);
-  opts = StringValueCStr(rblapack_opts);
-  n2 = NUM2INT(rblapack_n2);
-  n4 = NUM2INT(rblapack_n4);
-  name = StringValueCStr(rblapack_name);
-  n3 = NUM2INT(rblapack_n3);
-  n1 = NUM2INT(rblapack_n1);
-
-  __out__ = ilaenv_(&ispec, name, opts, &n1, &n2, &n3, &n4);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_ilaenv(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "ilaenv", rblapack_ilaenv, -1);
-}

data/ext/ilaprec.c

@@ -1,51 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer ilaprec_(char* prec);
-
-
-static VALUE
-rblapack_ilaprec(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_prec;
-  char prec; 
-  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.ilaprec( prec, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER FUNCTION ILAPREC( PREC )\n\n*  Purpose\n*  =======\n*\n*  This subroutine translated from a character string specifying an\n*  intermediate precision to the relevant BLAST-specified integer\n*  constant.\n*\n*  ILAPREC returns an INTEGER.  If ILAPREC < 0, then the input is not a\n*  character indicating a supported intermediate precision.  Otherwise\n*  ILAPREC returns the constant value corresponding to PREC.\n*\n\n*  Arguments\n*  =========\n*  PREC    (input) CHARACTER\n*          Specifies the form of the system of equations:\n*          = 'S':  Single\n*          = 'D':  Double\n*          = 'I':  Indigenous\n*          = 'X', 'E':  Extra\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.ilaprec( prec, [: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_prec = argv[0];
-  if (argc == 1) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  prec = StringValueCStr(rblapack_prec)[0];
-
-  __out__ = ilaprec_(&prec);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_ilaprec(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "ilaprec", rblapack_ilaprec, -1);
-}

data/ext/ilaslc.c

@@ -1,65 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer ilaslc_(integer* m, integer* n, real* a, integer* lda);
-
-
-static VALUE
-rblapack_ilaslc(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_a;
-  real *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.ilaslc( m, a, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER FUNCTION ILASLC( M, N, A, LDA )\n\n*  Purpose\n*  =======\n*\n*  ILASLC 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) REAL 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.ilaslc( 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_SFLOAT)
-    rblapack_a = na_change_type(rblapack_a, NA_SFLOAT);
-  a = NA_PTR_TYPE(rblapack_a, real*);
-
-  __out__ = ilaslc_(&m, &n, a, &lda);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_ilaslc(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "ilaslc", rblapack_ilaslc, -1);
-}

data/ext/ilaslr.c

@@ -1,65 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer ilaslr_(integer* m, integer* n, real* a, integer* lda);
-
-
-static VALUE
-rblapack_ilaslr(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_a;
-  real *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.ilaslr( m, a, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER FUNCTION ILASLR( M, N, A, LDA )\n\n*  Purpose\n*  =======\n*\n*  ILASLR 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) REAL 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.ilaslr( 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_SFLOAT)
-    rblapack_a = na_change_type(rblapack_a, NA_SFLOAT);
-  a = NA_PTR_TYPE(rblapack_a, real*);
-
-  __out__ = ilaslr_(&m, &n, a, &lda);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_ilaslr(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "ilaslr", rblapack_ilaslr, -1);
-}

data/ext/ilatrans.c

@@ -1,51 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer ilatrans_(char* trans);
-
-
-static VALUE
-rblapack_ilatrans(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_trans;
-  char trans; 
-  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.ilatrans( trans, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER FUNCTION ILATRANS( TRANS )\n\n*  Purpose\n*  =======\n*\n*  This subroutine translates from a character string specifying a\n*  transposition operation to the relevant BLAST-specified integer\n*  constant.\n*\n*  ILATRANS returns an INTEGER.  If ILATRANS < 0, then the input is not\n*  a character indicating a transposition operator.  Otherwise ILATRANS\n*  returns the constant value corresponding to TRANS.\n*\n\n*  Arguments\n*  =========\n*  TRANS   (input) CHARACTER*1\n*          Specifies the form of the system of equations:\n*          = 'N':  No transpose\n*          = 'T':  Transpose\n*          = 'C':  Conjugate transpose\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.ilatrans( trans, [: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_trans = argv[0];
-  if (argc == 1) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  trans = StringValueCStr(rblapack_trans)[0];
-
-  __out__ = ilatrans_(&trans);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_ilatrans(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "ilatrans", rblapack_ilatrans, -1);
-}

data/ext/ilauplo.c

@@ -1,51 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer ilauplo_(char* uplo);
-
-
-static VALUE
-rblapack_ilauplo(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_uplo;
-  char uplo; 
-  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.ilauplo( uplo, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER FUNCTION ILAUPLO( UPLO )\n\n*  Purpose\n*  =======\n*\n*  This subroutine translated from a character string specifying a\n*  upper- or lower-triangular matrix to the relevant BLAST-specified\n*  integer constant.\n*\n*  ILAUPLO returns an INTEGER.  If ILAUPLO < 0, then the input is not\n*  a character indicating an upper- or lower-triangular matrix.\n*  Otherwise ILAUPLO returns the constant value corresponding to UPLO.\n*\n\n*  Arguments\n*  =========\n*  UPLO    (input) CHARACTER\n*          = 'U':  A is upper triangular;\n*          = 'L':  A is lower triangular.\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.ilauplo( uplo, [: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_uplo = argv[0];
-  if (argc == 1) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  uplo = StringValueCStr(rblapack_uplo)[0];
-
-  __out__ = ilauplo_(&uplo);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_ilauplo(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "ilauplo", rblapack_ilauplo, -1);
-}

data/ext/ilaver.c

@@ -1,53 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID ilaver_(integer* vers_major, integer* vers_minor, integer* vers_patch);
-
-
-static VALUE
-rblapack_ilaver(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_vers_major;
-  integer vers_major; 
-  VALUE rblapack_vers_minor;
-  integer vers_minor; 
-  VALUE rblapack_vers_patch;
-  integer vers_patch; 
-
-
-  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  vers_major, vers_minor, vers_patch = NumRu::Lapack.ilaver( , [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE ILAVER( VERS_MAJOR, VERS_MINOR, VERS_PATCH )\n\n*  Purpose\n*  =======\n*\n*  This subroutine return the Lapack version.\n*\n\n*  Arguments\n*  =========\n*  VERS_MAJOR   (output) INTEGER\n*      return the lapack major version\n*  VERS_MINOR   (output) INTEGER\n*      return the lapack minor version from the major version\n*  VERS_PATCH   (output) INTEGER\n*      return the lapack patch version from the minor version\n\n*  =====================================================================\n*\n      INTEGER VERS_MAJOR, VERS_MINOR, VERS_PATCH\n*  =====================================================================\n      VERS_MAJOR = 3\n      VERS_MINOR = 3\n      VERS_PATCH = 0\n*  =====================================================================\n*\n      RETURN\n      END\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  vers_major, vers_minor, vers_patch = NumRu::Lapack.ilaver( , [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 0 && argc != 0)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 0)", argc);
-  if (argc == 0) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-
-  ilaver_(&vers_major, &vers_minor, &vers_patch);
-
-  rblapack_vers_major = INT2NUM(vers_major);
-  rblapack_vers_minor = INT2NUM(vers_minor);
-  rblapack_vers_patch = INT2NUM(vers_patch);
-  return rb_ary_new3(3, rblapack_vers_major, rblapack_vers_minor, rblapack_vers_patch);
-}
-
-void
-init_lapack_ilaver(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "ilaver", rblapack_ilaver, -1);
-}

data/ext/ilazlc.c

@@ -1,65 +0,0 @@
-#include "rb_lapack.h"
-
-extern integer ilazlc_(integer* m, integer* n, doublecomplex* a, integer* lda);
-
-
-static VALUE
-rblapack_ilazlc(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_a;
-  doublecomplex *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.ilazlc( m, a, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      INTEGER FUNCTION ILAZLC( M, N, A, LDA )\n\n*  Purpose\n*  =======\n*\n*  ILAZLC 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*16 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.ilazlc( 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_DCOMPLEX)
-    rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
-  a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
-
-  __out__ = ilazlc_(&m, &n, a, &lda);
-
-  rblapack___out__ = INT2NUM(__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_ilazlc(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "ilazlc", rblapack_ilazlc, -1);
-}