ruby-lapack 1.6 → 1.7

data/ext/zlapmr.c

@@ -1,97 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID zlapmr_(logical* forwrd, integer* m, integer* n, doublecomplex* x, integer* ldx, integer* k);
-
-
-static VALUE
-rblapack_zlapmr(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_forwrd;
-  logical forwrd; 
-  VALUE rblapack_x;
-  doublecomplex *x; 
-  VALUE rblapack_k;
-  integer *k; 
-  VALUE rblapack_x_out__;
-  doublecomplex *x_out__;
-  VALUE rblapack_k_out__;
-  integer *k_out__;
-
-  integer ldx;
-  integer n;
-  integer m;
-
-  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, k = NumRu::Lapack.zlapmr( forwrd, x, k, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE ZLAPMR( FORWRD, M, N, X, LDX, K )\n\n*  Purpose\n*  =======\n*\n*  ZLAPMR rearranges the rows of the M by N matrix X as specified\n*  by the permutation K(1),K(2),...,K(M) of the integers 1,...,M.\n*  If FORWRD = .TRUE.,  forward permutation:\n*\n*       X(K(I),*) is moved X(I,*) for I = 1,2,...,M.\n*\n*  If FORWRD = .FALSE., backward permutation:\n*\n*       X(I,*) is moved to X(K(I),*) for I = 1,2,...,M.\n*\n\n*  Arguments\n*  =========\n*\n*  FORWRD  (input) LOGICAL\n*          = .TRUE., forward permutation\n*          = .FALSE., backward permutation\n*\n*  M       (input) INTEGER\n*          The number of rows of the matrix X. M >= 0.\n*\n*  N       (input) INTEGER\n*          The number of columns of the matrix X. N >= 0.\n*\n*  X       (input/output) COMPLEX*16 array, dimension (LDX,N)\n*          On entry, the M by N matrix X.\n*          On exit, X contains the permuted matrix X.\n*\n*  LDX     (input) INTEGER\n*          The leading dimension of the array X, LDX >= MAX(1,M).\n*\n*  K       (input/output) INTEGER array, dimension (M)\n*          On entry, K contains the permutation vector. K is used as\n*          internal workspace, but reset to its original value on\n*          output.\n*\n\n*  =====================================================================\n*\n*     .. Local Scalars ..\n      INTEGER            I, IN, J, JJ\n      COMPLEX*16         TEMP\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  x, k = NumRu::Lapack.zlapmr( forwrd, x, k, [: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_forwrd = argv[0];
-  rblapack_x = argv[1];
-  rblapack_k = argv[2];
-  if (argc == 3) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  forwrd = (rblapack_forwrd == Qtrue);
-  if (!NA_IsNArray(rblapack_k))
-    rb_raise(rb_eArgError, "k (3th argument) must be NArray");
-  if (NA_RANK(rblapack_k) != 1)
-    rb_raise(rb_eArgError, "rank of k (3th argument) must be %d", 1);
-  m = NA_SHAPE0(rblapack_k);
-  if (NA_TYPE(rblapack_k) != NA_LINT)
-    rblapack_k = na_change_type(rblapack_k, NA_LINT);
-  k = NA_PTR_TYPE(rblapack_k, integer*);
-  if (!NA_IsNArray(rblapack_x))
-    rb_raise(rb_eArgError, "x (2th argument) must be NArray");
-  if (NA_RANK(rblapack_x) != 2)
-    rb_raise(rb_eArgError, "rank of x (2th argument) must be %d", 2);
-  ldx = NA_SHAPE0(rblapack_x);
-  n = NA_SHAPE1(rblapack_x);
-  if (NA_TYPE(rblapack_x) != NA_DCOMPLEX)
-    rblapack_x = na_change_type(rblapack_x, NA_DCOMPLEX);
-  x = NA_PTR_TYPE(rblapack_x, doublecomplex*);
-  {
-    int shape[2];
-    shape[0] = ldx;
-    shape[1] = n;
-    rblapack_x_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
-  }
-  x_out__ = NA_PTR_TYPE(rblapack_x_out__, doublecomplex*);
-  MEMCPY(x_out__, x, doublecomplex, NA_TOTAL(rblapack_x));
-  rblapack_x = rblapack_x_out__;
-  x = x_out__;
-  {
-    int shape[1];
-    shape[0] = m;
-    rblapack_k_out__ = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  k_out__ = NA_PTR_TYPE(rblapack_k_out__, integer*);
-  MEMCPY(k_out__, k, integer, NA_TOTAL(rblapack_k));
-  rblapack_k = rblapack_k_out__;
-  k = k_out__;
-
-  zlapmr_(&forwrd, &m, &n, x, &ldx, k);
-
-  return rb_ary_new3(2, rblapack_x, rblapack_k);
-}
-
-void
-init_lapack_zlapmr(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "zlapmr", rblapack_zlapmr, -1);
-}

data/ext/zlapmt.c

@@ -1,101 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID zlapmt_(logical* forwrd, integer* m, integer* n, doublecomplex* x, integer* ldx, integer* k);
-
-
-static VALUE
-rblapack_zlapmt(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_forwrd;
-  logical forwrd; 
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_x;
-  doublecomplex *x; 
-  VALUE rblapack_k;
-  integer *k; 
-  VALUE rblapack_x_out__;
-  doublecomplex *x_out__;
-  VALUE rblapack_k_out__;
-  integer *k_out__;
-
-  integer ldx;
-  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  x, k = NumRu::Lapack.zlapmt( forwrd, m, x, k, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE ZLAPMT( FORWRD, M, N, X, LDX, K )\n\n*  Purpose\n*  =======\n*\n*  ZLAPMT rearranges the columns of the M by N matrix X as specified\n*  by the permutation K(1),K(2),...,K(N) of the integers 1,...,N.\n*  If FORWRD = .TRUE.,  forward permutation:\n*\n*       X(*,K(J)) is moved X(*,J) for J = 1,2,...,N.\n*\n*  If FORWRD = .FALSE., backward permutation:\n*\n*       X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N.\n*\n\n*  Arguments\n*  =========\n*\n*  FORWRD  (input) LOGICAL\n*          = .TRUE., forward permutation\n*          = .FALSE., backward permutation\n*\n*  M       (input) INTEGER\n*          The number of rows of the matrix X. M >= 0.\n*\n*  N       (input) INTEGER\n*          The number of columns of the matrix X. N >= 0.\n*\n*  X       (input/output) COMPLEX*16 array, dimension (LDX,N)\n*          On entry, the M by N matrix X.\n*          On exit, X contains the permuted matrix X.\n*\n*  LDX     (input) INTEGER\n*          The leading dimension of the array X, LDX >= MAX(1,M).\n*\n*  K       (input/output) INTEGER array, dimension (N)\n*          On entry, K contains the permutation vector. K is used as\n*          internal workspace, but reset to its original value on\n*          output.\n*\n\n*  =====================================================================\n*\n*     .. Local Scalars ..\n      INTEGER            I, II, IN, J\n      COMPLEX*16         TEMP\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  x, k = NumRu::Lapack.zlapmt( forwrd, m, x, k, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 4 && argc != 4)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 4)", argc);
-  rblapack_forwrd = argv[0];
-  rblapack_m = argv[1];
-  rblapack_x = argv[2];
-  rblapack_k = argv[3];
-  if (argc == 4) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  forwrd = (rblapack_forwrd == Qtrue);
-  if (!NA_IsNArray(rblapack_x))
-    rb_raise(rb_eArgError, "x (3th argument) must be NArray");
-  if (NA_RANK(rblapack_x) != 2)
-    rb_raise(rb_eArgError, "rank of x (3th argument) must be %d", 2);
-  ldx = NA_SHAPE0(rblapack_x);
-  n = NA_SHAPE1(rblapack_x);
-  if (NA_TYPE(rblapack_x) != NA_DCOMPLEX)
-    rblapack_x = na_change_type(rblapack_x, NA_DCOMPLEX);
-  x = NA_PTR_TYPE(rblapack_x, doublecomplex*);
-  m = NUM2INT(rblapack_m);
-  if (!NA_IsNArray(rblapack_k))
-    rb_raise(rb_eArgError, "k (4th argument) must be NArray");
-  if (NA_RANK(rblapack_k) != 1)
-    rb_raise(rb_eArgError, "rank of k (4th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_k) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of k must be the same as shape 1 of x");
-  if (NA_TYPE(rblapack_k) != NA_LINT)
-    rblapack_k = na_change_type(rblapack_k, NA_LINT);
-  k = NA_PTR_TYPE(rblapack_k, integer*);
-  {
-    int shape[2];
-    shape[0] = ldx;
-    shape[1] = n;
-    rblapack_x_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
-  }
-  x_out__ = NA_PTR_TYPE(rblapack_x_out__, doublecomplex*);
-  MEMCPY(x_out__, x, doublecomplex, NA_TOTAL(rblapack_x));
-  rblapack_x = rblapack_x_out__;
-  x = x_out__;
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_k_out__ = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  k_out__ = NA_PTR_TYPE(rblapack_k_out__, integer*);
-  MEMCPY(k_out__, k, integer, NA_TOTAL(rblapack_k));
-  rblapack_k = rblapack_k_out__;
-  k = k_out__;
-
-  zlapmt_(&forwrd, &m, &n, x, &ldx, k);
-
-  return rb_ary_new3(2, rblapack_x, rblapack_k);
-}
-
-void
-init_lapack_zlapmt(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "zlapmt", rblapack_zlapmt, -1);
-}

data/ext/zlaqgb.c

@@ -1,117 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID zlaqgb_(integer* m, integer* n, integer* kl, integer* ku, doublecomplex* ab, integer* ldab, doublereal* r, doublereal* c, doublereal* rowcnd, doublereal* colcnd, doublereal* amax, char* equed);
-
-
-static VALUE
-rblapack_zlaqgb(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_kl;
-  integer kl; 
-  VALUE rblapack_ku;
-  integer ku; 
-  VALUE rblapack_ab;
-  doublecomplex *ab; 
-  VALUE rblapack_r;
-  doublereal *r; 
-  VALUE rblapack_c;
-  doublereal *c; 
-  VALUE rblapack_rowcnd;
-  doublereal rowcnd; 
-  VALUE rblapack_colcnd;
-  doublereal colcnd; 
-  VALUE rblapack_amax;
-  doublereal amax; 
-  VALUE rblapack_equed;
-  char equed; 
-  VALUE rblapack_ab_out__;
-  doublecomplex *ab_out__;
-
-  integer ldab;
-  integer n;
-  integer m;
-
-  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  equed, ab = NumRu::Lapack.zlaqgb( kl, ku, ab, r, c, rowcnd, colcnd, amax, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE ZLAQGB( M, N, KL, KU, AB, LDAB, R, C, ROWCND, COLCND, AMAX, EQUED )\n\n*  Purpose\n*  =======\n*\n*  ZLAQGB equilibrates a general M by N band matrix A with KL\n*  subdiagonals and KU superdiagonals using the row and scaling factors\n*  in the vectors R and C.\n*\n\n*  Arguments\n*  =========\n*\n*  M       (input) INTEGER\n*          The number of rows of the matrix A.  M >= 0.\n*\n*  N       (input) INTEGER\n*          The number of columns of the matrix A.  N >= 0.\n*\n*  KL      (input) INTEGER\n*          The number of subdiagonals within the band of A.  KL >= 0.\n*\n*  KU      (input) INTEGER\n*          The number of superdiagonals within the band of A.  KU >= 0.\n*\n*  AB      (input/output) COMPLEX*16 array, dimension (LDAB,N)\n*          On entry, the matrix A in band storage, in rows 1 to KL+KU+1.\n*          The j-th column of A is stored in the j-th column of the\n*          array AB as follows:\n*          AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)\n*\n*          On exit, the equilibrated matrix, in the same storage format\n*          as A.  See EQUED for the form of the equilibrated matrix.\n*\n*  LDAB    (input) INTEGER\n*          The leading dimension of the array AB.  LDA >= KL+KU+1.\n*\n*  R       (input) DOUBLE PRECISION array, dimension (M)\n*          The row scale factors for A.\n*\n*  C       (input) DOUBLE PRECISION array, dimension (N)\n*          The column scale factors for A.\n*\n*  ROWCND  (input) DOUBLE PRECISION\n*          Ratio of the smallest R(i) to the largest R(i).\n*\n*  COLCND  (input) DOUBLE PRECISION\n*          Ratio of the smallest C(i) to the largest C(i).\n*\n*  AMAX    (input) DOUBLE PRECISION\n*          Absolute value of largest matrix entry.\n*\n*  EQUED   (output) CHARACTER*1\n*          Specifies the form of equilibration that was done.\n*          = 'N':  No equilibration\n*          = 'R':  Row equilibration, i.e., A has been premultiplied by\n*                  diag(R).\n*          = 'C':  Column equilibration, i.e., A has been postmultiplied\n*                  by diag(C).\n*          = 'B':  Both row and column equilibration, i.e., A has been\n*                  replaced by diag(R) * A * diag(C).\n*\n*  Internal Parameters\n*  ===================\n*\n*  THRESH is a threshold value used to decide if row or column scaling\n*  should be done based on the ratio of the row or column scaling\n*  factors.  If ROWCND < THRESH, row scaling is done, and if\n*  COLCND < THRESH, column scaling is done.\n*\n*  LARGE and SMALL are threshold values used to decide if row scaling\n*  should be done based on the absolute size of the largest matrix\n*  element.  If AMAX > LARGE or AMAX < SMALL, row scaling is done.\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  equed, ab = NumRu::Lapack.zlaqgb( kl, ku, ab, r, c, rowcnd, colcnd, amax, [: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_kl = argv[0];
-  rblapack_ku = argv[1];
-  rblapack_ab = argv[2];
-  rblapack_r = argv[3];
-  rblapack_c = argv[4];
-  rblapack_rowcnd = argv[5];
-  rblapack_colcnd = argv[6];
-  rblapack_amax = argv[7];
-  if (argc == 8) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  kl = NUM2INT(rblapack_kl);
-  if (!NA_IsNArray(rblapack_ab))
-    rb_raise(rb_eArgError, "ab (3th argument) must be NArray");
-  if (NA_RANK(rblapack_ab) != 2)
-    rb_raise(rb_eArgError, "rank of ab (3th argument) must be %d", 2);
-  ldab = NA_SHAPE0(rblapack_ab);
-  n = NA_SHAPE1(rblapack_ab);
-  if (NA_TYPE(rblapack_ab) != NA_DCOMPLEX)
-    rblapack_ab = na_change_type(rblapack_ab, NA_DCOMPLEX);
-  ab = NA_PTR_TYPE(rblapack_ab, doublecomplex*);
-  if (!NA_IsNArray(rblapack_c))
-    rb_raise(rb_eArgError, "c (5th argument) must be NArray");
-  if (NA_RANK(rblapack_c) != 1)
-    rb_raise(rb_eArgError, "rank of c (5th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_c) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of c must be the same as shape 1 of ab");
-  if (NA_TYPE(rblapack_c) != NA_DFLOAT)
-    rblapack_c = na_change_type(rblapack_c, NA_DFLOAT);
-  c = NA_PTR_TYPE(rblapack_c, doublereal*);
-  colcnd = NUM2DBL(rblapack_colcnd);
-  ku = NUM2INT(rblapack_ku);
-  rowcnd = NUM2DBL(rblapack_rowcnd);
-  if (!NA_IsNArray(rblapack_r))
-    rb_raise(rb_eArgError, "r (4th argument) must be NArray");
-  if (NA_RANK(rblapack_r) != 1)
-    rb_raise(rb_eArgError, "rank of r (4th argument) must be %d", 1);
-  m = NA_SHAPE0(rblapack_r);
-  if (NA_TYPE(rblapack_r) != NA_DFLOAT)
-    rblapack_r = na_change_type(rblapack_r, NA_DFLOAT);
-  r = NA_PTR_TYPE(rblapack_r, doublereal*);
-  amax = NUM2DBL(rblapack_amax);
-  {
-    int shape[2];
-    shape[0] = ldab;
-    shape[1] = n;
-    rblapack_ab_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
-  }
-  ab_out__ = NA_PTR_TYPE(rblapack_ab_out__, doublecomplex*);
-  MEMCPY(ab_out__, ab, doublecomplex, NA_TOTAL(rblapack_ab));
-  rblapack_ab = rblapack_ab_out__;
-  ab = ab_out__;
-
-  zlaqgb_(&m, &n, &kl, &ku, ab, &ldab, r, c, &rowcnd, &colcnd, &amax, &equed);
-
-  rblapack_equed = rb_str_new(&equed,1);
-  return rb_ary_new3(2, rblapack_equed, rblapack_ab);
-}
-
-void
-init_lapack_zlaqgb(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "zlaqgb", rblapack_zlaqgb, -1);
-}

data/ext/zlaqge.c

@@ -1,109 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID zlaqge_(integer* m, integer* n, doublecomplex* a, integer* lda, doublereal* r, doublereal* c, doublereal* rowcnd, doublereal* colcnd, doublereal* amax, char* equed);
-
-
-static VALUE
-rblapack_zlaqge(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_a;
-  doublecomplex *a; 
-  VALUE rblapack_r;
-  doublereal *r; 
-  VALUE rblapack_c;
-  doublereal *c; 
-  VALUE rblapack_rowcnd;
-  doublereal rowcnd; 
-  VALUE rblapack_colcnd;
-  doublereal colcnd; 
-  VALUE rblapack_amax;
-  doublereal amax; 
-  VALUE rblapack_equed;
-  char equed; 
-  VALUE rblapack_a_out__;
-  doublecomplex *a_out__;
-
-  integer lda;
-  integer n;
-  integer m;
-
-  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  equed, a = NumRu::Lapack.zlaqge( a, r, c, rowcnd, colcnd, amax, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE ZLAQGE( M, N, A, LDA, R, C, ROWCND, COLCND, AMAX, EQUED )\n\n*  Purpose\n*  =======\n*\n*  ZLAQGE equilibrates a general M by N matrix A using the row and\n*  column scaling factors in the vectors R and C.\n*\n\n*  Arguments\n*  =========\n*\n*  M       (input) INTEGER\n*          The number of rows of the matrix A.  M >= 0.\n*\n*  N       (input) INTEGER\n*          The number of columns of the matrix A.  N >= 0.\n*\n*  A       (input/output) COMPLEX*16 array, dimension (LDA,N)\n*          On entry, the M by N matrix A.\n*          On exit, the equilibrated matrix.  See EQUED for the form of\n*          the equilibrated matrix.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A.  LDA >= max(M,1).\n*\n*  R       (input) DOUBLE PRECISION array, dimension (M)\n*          The row scale factors for A.\n*\n*  C       (input) DOUBLE PRECISION array, dimension (N)\n*          The column scale factors for A.\n*\n*  ROWCND  (input) DOUBLE PRECISION\n*          Ratio of the smallest R(i) to the largest R(i).\n*\n*  COLCND  (input) DOUBLE PRECISION\n*          Ratio of the smallest C(i) to the largest C(i).\n*\n*  AMAX    (input) DOUBLE PRECISION\n*          Absolute value of largest matrix entry.\n*\n*  EQUED   (output) CHARACTER*1\n*          Specifies the form of equilibration that was done.\n*          = 'N':  No equilibration\n*          = 'R':  Row equilibration, i.e., A has been premultiplied by\n*                  diag(R).\n*          = 'C':  Column equilibration, i.e., A has been postmultiplied\n*                  by diag(C).\n*          = 'B':  Both row and column equilibration, i.e., A has been\n*                  replaced by diag(R) * A * diag(C).\n*\n*  Internal Parameters\n*  ===================\n*\n*  THRESH is a threshold value used to decide if row or column scaling\n*  should be done based on the ratio of the row or column scaling\n*  factors.  If ROWCND < THRESH, row scaling is done, and if\n*  COLCND < THRESH, column scaling is done.\n*\n*  LARGE and SMALL are threshold values used to decide if row scaling\n*  should be done based on the absolute size of the largest matrix\n*  element.  If AMAX > LARGE or AMAX < SMALL, row scaling is done.\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  equed, a = NumRu::Lapack.zlaqge( a, r, c, rowcnd, colcnd, amax, [: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_a = argv[0];
-  rblapack_r = argv[1];
-  rblapack_c = argv[2];
-  rblapack_rowcnd = argv[3];
-  rblapack_colcnd = argv[4];
-  rblapack_amax = argv[5];
-  if (argc == 6) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (1th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (1th 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*);
-  if (!NA_IsNArray(rblapack_c))
-    rb_raise(rb_eArgError, "c (3th argument) must be NArray");
-  if (NA_RANK(rblapack_c) != 1)
-    rb_raise(rb_eArgError, "rank of c (3th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_c) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of c must be the same as shape 1 of a");
-  if (NA_TYPE(rblapack_c) != NA_DFLOAT)
-    rblapack_c = na_change_type(rblapack_c, NA_DFLOAT);
-  c = NA_PTR_TYPE(rblapack_c, doublereal*);
-  colcnd = NUM2DBL(rblapack_colcnd);
-  if (!NA_IsNArray(rblapack_r))
-    rb_raise(rb_eArgError, "r (2th argument) must be NArray");
-  if (NA_RANK(rblapack_r) != 1)
-    rb_raise(rb_eArgError, "rank of r (2th argument) must be %d", 1);
-  m = NA_SHAPE0(rblapack_r);
-  if (NA_TYPE(rblapack_r) != NA_DFLOAT)
-    rblapack_r = na_change_type(rblapack_r, NA_DFLOAT);
-  r = NA_PTR_TYPE(rblapack_r, doublereal*);
-  amax = NUM2DBL(rblapack_amax);
-  rowcnd = NUM2DBL(rblapack_rowcnd);
-  {
-    int shape[2];
-    shape[0] = lda;
-    shape[1] = n;
-    rblapack_a_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
-  }
-  a_out__ = NA_PTR_TYPE(rblapack_a_out__, doublecomplex*);
-  MEMCPY(a_out__, a, doublecomplex, NA_TOTAL(rblapack_a));
-  rblapack_a = rblapack_a_out__;
-  a = a_out__;
-
-  zlaqge_(&m, &n, a, &lda, r, c, &rowcnd, &colcnd, &amax, &equed);
-
-  rblapack_equed = rb_str_new(&equed,1);
-  return rb_ary_new3(2, rblapack_equed, rblapack_a);
-}
-
-void
-init_lapack_zlaqge(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "zlaqge", rblapack_zlaqge, -1);
-}

data/ext/zlaqhb.c

@@ -1,97 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID zlaqhb_(char* uplo, integer* n, integer* kd, doublecomplex* ab, integer* ldab, doublereal* s, doublereal* scond, doublereal* amax, char* equed);
-
-
-static VALUE
-rblapack_zlaqhb(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_uplo;
-  char uplo; 
-  VALUE rblapack_kd;
-  integer kd; 
-  VALUE rblapack_ab;
-  doublecomplex *ab; 
-  VALUE rblapack_scond;
-  doublereal scond; 
-  VALUE rblapack_amax;
-  doublereal amax; 
-  VALUE rblapack_s;
-  doublereal *s; 
-  VALUE rblapack_equed;
-  char equed; 
-  VALUE rblapack_ab_out__;
-  doublecomplex *ab_out__;
-
-  integer ldab;
-  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  s, equed, ab = NumRu::Lapack.zlaqhb( uplo, kd, ab, scond, amax, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE ZLAQHB( UPLO, N, KD, AB, LDAB, S, SCOND, AMAX, EQUED )\n\n*  Purpose\n*  =======\n*\n*  ZLAQHB equilibrates a symmetric band matrix A using the scaling\n*  factors in the vector S.\n*\n\n*  Arguments\n*  =========\n*\n*  UPLO    (input) CHARACTER*1\n*          Specifies whether the upper or lower triangular part of the\n*          symmetric matrix A is stored.\n*          = 'U':  Upper triangular\n*          = 'L':  Lower triangular\n*\n*  N       (input) INTEGER\n*          The order of the matrix A.  N >= 0.\n*\n*  KD      (input) INTEGER\n*          The number of super-diagonals of the matrix A if UPLO = 'U',\n*          or the number of sub-diagonals if UPLO = 'L'.  KD >= 0.\n*\n*  AB      (input/output) COMPLEX*16 array, dimension (LDAB,N)\n*          On entry, the upper or lower triangle of the symmetric band\n*          matrix A, stored in the first KD+1 rows of the array.  The\n*          j-th column of A is stored in the j-th column of the array AB\n*          as follows:\n*          if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;\n*          if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).\n*\n*          On exit, if INFO = 0, the triangular factor U or L from the\n*          Cholesky factorization A = U'*U or A = L*L' of the band\n*          matrix A, in the same storage format as A.\n*\n*  LDAB    (input) INTEGER\n*          The leading dimension of the array AB.  LDAB >= KD+1.\n*\n*  S       (output) DOUBLE PRECISION array, dimension (N)\n*          The scale factors for A.\n*\n*  SCOND   (input) DOUBLE PRECISION\n*          Ratio of the smallest S(i) to the largest S(i).\n*\n*  AMAX    (input) DOUBLE PRECISION\n*          Absolute value of largest matrix entry.\n*\n*  EQUED   (output) CHARACTER*1\n*          Specifies whether or not equilibration was done.\n*          = 'N':  No equilibration.\n*          = 'Y':  Equilibration was done, i.e., A has been replaced by\n*                  diag(S) * A * diag(S).\n*\n*  Internal Parameters\n*  ===================\n*\n*  THRESH is a threshold value used to decide if scaling should be done\n*  based on the ratio of the scaling factors.  If SCOND < THRESH,\n*  scaling is done.\n*\n*  LARGE and SMALL are threshold values used to decide if scaling should\n*  be done based on the absolute size of the largest matrix element.\n*  If AMAX > LARGE or AMAX < SMALL, scaling is done.\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  s, equed, ab = NumRu::Lapack.zlaqhb( uplo, kd, ab, scond, amax, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 5 && argc != 5)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 5)", argc);
-  rblapack_uplo = argv[0];
-  rblapack_kd = argv[1];
-  rblapack_ab = argv[2];
-  rblapack_scond = argv[3];
-  rblapack_amax = argv[4];
-  if (argc == 5) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  uplo = StringValueCStr(rblapack_uplo)[0];
-  if (!NA_IsNArray(rblapack_ab))
-    rb_raise(rb_eArgError, "ab (3th argument) must be NArray");
-  if (NA_RANK(rblapack_ab) != 2)
-    rb_raise(rb_eArgError, "rank of ab (3th argument) must be %d", 2);
-  ldab = NA_SHAPE0(rblapack_ab);
-  n = NA_SHAPE1(rblapack_ab);
-  if (NA_TYPE(rblapack_ab) != NA_DCOMPLEX)
-    rblapack_ab = na_change_type(rblapack_ab, NA_DCOMPLEX);
-  ab = NA_PTR_TYPE(rblapack_ab, doublecomplex*);
-  amax = NUM2DBL(rblapack_amax);
-  kd = NUM2INT(rblapack_kd);
-  scond = NUM2DBL(rblapack_scond);
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_s = na_make_object(NA_DFLOAT, 1, shape, cNArray);
-  }
-  s = NA_PTR_TYPE(rblapack_s, doublereal*);
-  {
-    int shape[2];
-    shape[0] = ldab;
-    shape[1] = n;
-    rblapack_ab_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
-  }
-  ab_out__ = NA_PTR_TYPE(rblapack_ab_out__, doublecomplex*);
-  MEMCPY(ab_out__, ab, doublecomplex, NA_TOTAL(rblapack_ab));
-  rblapack_ab = rblapack_ab_out__;
-  ab = ab_out__;
-
-  zlaqhb_(&uplo, &n, &kd, ab, &ldab, s, &scond, &amax, &equed);
-
-  rblapack_equed = rb_str_new(&equed,1);
-  return rb_ary_new3(3, rblapack_s, rblapack_equed, rblapack_ab);
-}
-
-void
-init_lapack_zlaqhb(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "zlaqhb", rblapack_zlaqhb, -1);
-}