ruby-lapack 1.6 → 1.7

data/ext/cla_gbrpvgrw.c

@@ -1,87 +0,0 @@
-#include "rb_lapack.h"
-
-extern real cla_gbrpvgrw_(integer* n, integer* kl, integer* ku, integer* ncols, complex* ab, integer* ldab, complex* afb, integer* ldafb);
-
-
-static VALUE
-rblapack_cla_gbrpvgrw(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_kl;
-  integer kl; 
-  VALUE rblapack_ku;
-  integer ku; 
-  VALUE rblapack_ncols;
-  integer ncols; 
-  VALUE rblapack_ab;
-  complex *ab; 
-  VALUE rblapack_afb;
-  complex *afb; 
-  VALUE rblapack___out__;
-  real __out__; 
-
-  integer ldab;
-  integer n;
-  integer ldafb;
-
-  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.cla_gbrpvgrw( kl, ku, ncols, ab, afb, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      REAL FUNCTION CLA_GBRPVGRW( N, KL, KU, NCOLS, AB, LDAB, AFB, LDAFB )\n\n*  Purpose\n*  =======\n*\n*  CLA_GBRPVGRW computes the reciprocal pivot growth factor\n*  norm(A)/norm(U). The \"max absolute element\" norm is used. If this is\n*  much less than 1, the stability of the LU factorization of the\n*  (equilibrated) matrix A could be poor. This also means that the\n*  solution X, estimated condition numbers, and error bounds could be\n*  unreliable.\n*\n\n*  Arguments\n*  =========\n*\n*     N       (input) INTEGER\n*     The number of linear equations, i.e., the order of the\n*     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*     NCOLS   (input) INTEGER\n*     The number of columns of the matrix A.  NCOLS >= 0.\n*\n*     AB      (input) COMPLEX 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(N,j+kl)\n*\n*     LDAB    (input) INTEGER\n*     The leading dimension of the array AB.  LDAB >= KL+KU+1.\n*\n*     AFB     (input) COMPLEX array, dimension (LDAFB,N)\n*     Details of the LU factorization of the band matrix A, as\n*     computed by CGBTRF.  U is stored as an upper triangular\n*     band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1,\n*     and the multipliers used during the factorization are stored\n*     in rows KL+KU+2 to 2*KL+KU+1.\n*\n*     LDAFB   (input) INTEGER\n*     The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1.\n*\n\n*  =====================================================================\n*\n*     .. Local Scalars ..\n      INTEGER            I, J, KD\n      REAL               AMAX, UMAX, RPVGRW\n      COMPLEX            ZDUM\n*     ..\n*     .. Intrinsic Functions ..\n      INTRINSIC          ABS, MAX, MIN, REAL, AIMAG\n*     ..\n*     .. Statement Functions ..\n      REAL               CABS1\n*     ..\n*     .. Statement Function Definitions ..\n      CABS1( ZDUM ) = ABS( REAL( ZDUM ) ) + ABS( AIMAG( ZDUM ) )\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  __out__ = NumRu::Lapack.cla_gbrpvgrw( kl, ku, ncols, ab, afb, [: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_kl = argv[0];
-  rblapack_ku = argv[1];
-  rblapack_ncols = argv[2];
-  rblapack_ab = argv[3];
-  rblapack_afb = argv[4];
-  if (argc == 5) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  kl = NUM2INT(rblapack_kl);
-  ncols = NUM2INT(rblapack_ncols);
-  if (!NA_IsNArray(rblapack_afb))
-    rb_raise(rb_eArgError, "afb (5th argument) must be NArray");
-  if (NA_RANK(rblapack_afb) != 2)
-    rb_raise(rb_eArgError, "rank of afb (5th argument) must be %d", 2);
-  ldafb = NA_SHAPE0(rblapack_afb);
-  n = NA_SHAPE1(rblapack_afb);
-  if (NA_TYPE(rblapack_afb) != NA_SCOMPLEX)
-    rblapack_afb = na_change_type(rblapack_afb, NA_SCOMPLEX);
-  afb = NA_PTR_TYPE(rblapack_afb, complex*);
-  ku = NUM2INT(rblapack_ku);
-  if (!NA_IsNArray(rblapack_ab))
-    rb_raise(rb_eArgError, "ab (4th argument) must be NArray");
-  if (NA_RANK(rblapack_ab) != 2)
-    rb_raise(rb_eArgError, "rank of ab (4th argument) must be %d", 2);
-  ldab = NA_SHAPE0(rblapack_ab);
-  if (NA_SHAPE1(rblapack_ab) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of ab must be the same as shape 1 of afb");
-  if (NA_TYPE(rblapack_ab) != NA_SCOMPLEX)
-    rblapack_ab = na_change_type(rblapack_ab, NA_SCOMPLEX);
-  ab = NA_PTR_TYPE(rblapack_ab, complex*);
-
-  __out__ = cla_gbrpvgrw_(&n, &kl, &ku, &ncols, ab, &ldab, afb, &ldafb);
-
-  rblapack___out__ = rb_float_new((double)__out__);
-  return rblapack___out__;
-}
-
-void
-init_lapack_cla_gbrpvgrw(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "cla_gbrpvgrw", rblapack_cla_gbrpvgrw, -1);
-}

data/ext/cla_geamv.c

@@ -1,117 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID cla_geamv_(integer* trans, integer* m, integer* n, real* alpha, complex* a, integer* lda, complex* x, integer* incx, real* beta, real* y, integer* incy);
-
-
-static VALUE
-rblapack_cla_geamv(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_trans;
-  integer trans; 
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_alpha;
-  real alpha; 
-  VALUE rblapack_a;
-  complex *a; 
-  VALUE rblapack_x;
-  complex *x; 
-  VALUE rblapack_incx;
-  integer incx; 
-  VALUE rblapack_beta;
-  real beta; 
-  VALUE rblapack_y;
-  real *y; 
-  VALUE rblapack_incy;
-  integer incy; 
-  VALUE rblapack_y_out__;
-  real *y_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  y = NumRu::Lapack.cla_geamv( trans, m, alpha, a, x, incx, beta, y, incy, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE CLA_GEAMV ( TRANS, M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY )\n\n*  Purpose\n*  =======\n*\n*  CLA_GEAMV  performs one of the matrix-vector operations\n*\n*          y := alpha*abs(A)*abs(x) + beta*abs(y),\n*     or   y := alpha*abs(A)'*abs(x) + beta*abs(y),\n*\n*  where alpha and beta are scalars, x and y are vectors and A is an\n*  m by n matrix.\n*\n*  This function is primarily used in calculating error bounds.\n*  To protect against underflow during evaluation, components in\n*  the resulting vector are perturbed away from zero by (N+1)\n*  times the underflow threshold.  To prevent unnecessarily large\n*  errors for block-structure embedded in general matrices,\n*  \"symbolically\" zero components are not perturbed.  A zero\n*  entry is considered \"symbolic\" if all multiplications involved\n*  in computing that entry have at least one zero multiplicand.\n*\n\n*  Arguments\n*  ==========\n*\n*  TRANS   (input) INTEGER\n*           On entry, TRANS specifies the operation to be performed as\n*           follows:\n*\n*             BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)\n*             BLAS_TRANS         y := alpha*abs(A')*abs(x) + beta*abs(y)\n*             BLAS_CONJ_TRANS    y := alpha*abs(A')*abs(x) + beta*abs(y)\n*\n*           Unchanged on exit.\n*\n*  M       (input) INTEGER\n*           On entry, M specifies the number of rows of the matrix A.\n*           M must be at least zero.\n*           Unchanged on exit.\n*\n*  N       (input) INTEGER\n*           On entry, N specifies the number of columns of the matrix A.\n*           N must be at least zero.\n*           Unchanged on exit.\n*\n*  ALPHA   (input) REAL\n*           On entry, ALPHA specifies the scalar alpha.\n*           Unchanged on exit.\n*\n*  A       (input) COMPLEX array, dimension (LDA,n)\n*           Before entry, the leading m by n part of the array A must\n*           contain the matrix of coefficients.\n*           Unchanged on exit.\n*\n*  LDA     (input) INTEGER\n*           On entry, LDA specifies the first dimension of A as declared\n*           in the calling (sub) program. LDA must be at least\n*           max( 1, m ).\n*           Unchanged on exit.\n*\n*  X       (input) COMPLEX array, dimension\n*           ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'\n*           and at least\n*           ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.\n*           Before entry, the incremented array X must contain the\n*           vector x.\n*           Unchanged on exit.\n*\n*  INCX    (input) INTEGER\n*           On entry, INCX specifies the increment for the elements of\n*           X. INCX must not be zero.\n*           Unchanged on exit.\n*\n*  BETA    (input) REAL\n*           On entry, BETA specifies the scalar beta. When BETA is\n*           supplied as zero then Y need not be set on input.\n*           Unchanged on exit.\n*\n*  Y       (input/output) REAL array, dimension\n*           ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'\n*           and at least\n*           ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.\n*           Before entry with BETA non-zero, the incremented array Y\n*           must contain the vector y. On exit, Y is overwritten by the\n*           updated vector y.\n*\n*  INCY    (input) INTEGER\n*           On entry, INCY specifies the increment for the elements of\n*           Y. INCY must not be zero.\n*           Unchanged on exit.\n*\n*\n*  Level 2 Blas routine.\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  y = NumRu::Lapack.cla_geamv( trans, m, alpha, a, x, incx, beta, y, incy, [: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_trans = argv[0];
-  rblapack_m = argv[1];
-  rblapack_alpha = argv[2];
-  rblapack_a = argv[3];
-  rblapack_x = argv[4];
-  rblapack_incx = argv[5];
-  rblapack_beta = argv[6];
-  rblapack_y = argv[7];
-  rblapack_incy = argv[8];
-  if (argc == 9) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  trans = NUM2INT(rblapack_trans);
-  alpha = (real)NUM2DBL(rblapack_alpha);
-  incx = NUM2INT(rblapack_incx);
-  incy = NUM2INT(rblapack_incy);
-  m = NUM2INT(rblapack_m);
-  beta = (real)NUM2DBL(rblapack_beta);
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (4th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (4th 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*);
-  if (!NA_IsNArray(rblapack_y))
-    rb_raise(rb_eArgError, "y (8th argument) must be NArray");
-  if (NA_RANK(rblapack_y) != 1)
-    rb_raise(rb_eArgError, "rank of y (8th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_y) != (trans == ilatrans_("N") ? 1 + ( m - 1 )*abs( incy ) : 1 + ( n - 1 )*abs( incy )))
-    rb_raise(rb_eRuntimeError, "shape 0 of y must be %d", trans == ilatrans_("N") ? 1 + ( m - 1 )*abs( incy ) : 1 + ( n - 1 )*abs( 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_x))
-    rb_raise(rb_eArgError, "x (5th argument) must be NArray");
-  if (NA_RANK(rblapack_x) != 1)
-    rb_raise(rb_eArgError, "rank of x (5th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_x) != (trans == ilatrans_("N") ? 1 + ( n - 1 )*abs( incx ) : 1 + ( m - 1 )*abs( incx )))
-    rb_raise(rb_eRuntimeError, "shape 0 of x must be %d", trans == ilatrans_("N") ? 1 + ( n - 1 )*abs( incx ) : 1 + ( m - 1 )*abs( incx ));
-  if (NA_TYPE(rblapack_x) != NA_SCOMPLEX)
-    rblapack_x = na_change_type(rblapack_x, NA_SCOMPLEX);
-  x = NA_PTR_TYPE(rblapack_x, complex*);
-  {
-    int shape[1];
-    shape[0] = trans == ilatrans_("N") ? 1 + ( m - 1 )*abs( incy ) : 1 + ( n - 1 )*abs( 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__;
-
-  cla_geamv_(&trans, &m, &n, &alpha, a, &lda, x, &incx, &beta, y, &incy);
-
-  return rblapack_y;
-}
-
-void
-init_lapack_cla_geamv(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "cla_geamv", rblapack_cla_geamv, -1);
-}

data/ext/cla_gercond_c.c

@@ -1,134 +0,0 @@
-#include "rb_lapack.h"
-
-extern real cla_gercond_c_(char* trans, integer* n, complex* a, integer* lda, complex* af, integer* ldaf, integer* ipiv, real* c, logical* capply, integer* info, complex* work, real* rwork);
-
-
-static VALUE
-rblapack_cla_gercond_c(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_trans;
-  char trans; 
-  VALUE rblapack_a;
-  complex *a; 
-  VALUE rblapack_af;
-  complex *af; 
-  VALUE rblapack_ipiv;
-  integer *ipiv; 
-  VALUE rblapack_c;
-  real *c; 
-  VALUE rblapack_capply;
-  logical capply; 
-  VALUE rblapack_work;
-  complex *work; 
-  VALUE rblapack_rwork;
-  real *rwork; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack___out__;
-  real __out__; 
-
-  integer lda;
-  integer n;
-  integer ldaf;
-
-  VALUE rblapack_options;
-  if (argc > 0 && TYPE(argv[argc-1]) == T_HASH) {
-    argc--;
-    rblapack_options = argv[argc];
-    if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
-      printf("%s\n", "USAGE:\n  info, __out__ = NumRu::Lapack.cla_gercond_c( trans, a, af, ipiv, c, capply, work, rwork, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      REAL FUNCTION CLA_GERCOND_C( TRANS, N, A, LDA, AF, LDAF, IPIV, C, CAPPLY, INFO, WORK, RWORK )\n\n*  Purpose\n*  =======\n* \n*     CLA_GERCOND_C computes the infinity norm condition number of\n*     op(A) * inv(diag(C)) where C is a REAL vector.\n*\n\n*  Arguments\n*  =========\n*\n*     TRANS   (input) CHARACTER*1\n*     Specifies the form of the system of equations:\n*       = 'N':  A * X = B     (No transpose)\n*       = 'T':  A**T * X = B  (Transpose)\n*       = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)\n*\n*     N       (input) INTEGER\n*     The number of linear equations, i.e., the order of the\n*     matrix A.  N >= 0.\n*\n*     A       (input) COMPLEX array, dimension (LDA,N)\n*     On entry, the N-by-N matrix A\n*\n*     LDA     (input) INTEGER\n*     The leading dimension of the array A.  LDA >= max(1,N).\n*\n*     AF      (input) COMPLEX array, dimension (LDAF,N)\n*     The factors L and U from the factorization\n*     A = P*L*U as computed by CGETRF.\n*\n*     LDAF    (input) INTEGER\n*     The leading dimension of the array AF.  LDAF >= max(1,N).\n*\n*     IPIV    (input) INTEGER array, dimension (N)\n*     The pivot indices from the factorization A = P*L*U\n*     as computed by CGETRF; row i of the matrix was interchanged\n*     with row IPIV(i).\n*\n*     C       (input) REAL array, dimension (N)\n*     The vector C in the formula op(A) * inv(diag(C)).\n*\n*     CAPPLY  (input) LOGICAL\n*     If .TRUE. then access the vector C in the formula above.\n*\n*     INFO    (output) INTEGER\n*       = 0:  Successful exit.\n*     i > 0:  The ith argument is invalid.\n*\n*     WORK    (input) COMPLEX array, dimension (2*N).\n*     Workspace.\n*\n*     RWORK   (input) REAL array, dimension (N).\n*     Workspace.\n*\n\n*  =====================================================================\n*\n*     .. Local Scalars ..\n      LOGICAL            NOTRANS\n      INTEGER            KASE, I, J\n      REAL               AINVNM, ANORM, TMP\n      COMPLEX            ZDUM\n*     ..\n*     .. Local Arrays ..\n      INTEGER            ISAVE( 3 )\n*     ..\n*     .. External Functions ..\n      LOGICAL            LSAME\n      EXTERNAL           LSAME\n*     ..\n*     .. External Subroutines ..\n      EXTERNAL           CLACN2, CGETRS, XERBLA\n*     ..\n*     .. Intrinsic Functions ..\n      INTRINSIC          ABS, MAX, REAL, AIMAG\n*     ..\n*     .. Statement Functions ..\n      REAL               CABS1\n*     ..\n*     .. Statement Function Definitions ..\n      CABS1( ZDUM ) = ABS( REAL( ZDUM ) ) + ABS( AIMAG( ZDUM ) )\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  info, __out__ = NumRu::Lapack.cla_gercond_c( trans, a, af, ipiv, c, capply, work, rwork, [: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_trans = argv[0];
-  rblapack_a = argv[1];
-  rblapack_af = argv[2];
-  rblapack_ipiv = argv[3];
-  rblapack_c = argv[4];
-  rblapack_capply = argv[5];
-  rblapack_work = argv[6];
-  rblapack_rwork = argv[7];
-  if (argc == 8) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  trans = StringValueCStr(rblapack_trans)[0];
-  if (!NA_IsNArray(rblapack_af))
-    rb_raise(rb_eArgError, "af (3th argument) must be NArray");
-  if (NA_RANK(rblapack_af) != 2)
-    rb_raise(rb_eArgError, "rank of af (3th argument) must be %d", 2);
-  ldaf = NA_SHAPE0(rblapack_af);
-  n = NA_SHAPE1(rblapack_af);
-  if (NA_TYPE(rblapack_af) != NA_SCOMPLEX)
-    rblapack_af = na_change_type(rblapack_af, NA_SCOMPLEX);
-  af = NA_PTR_TYPE(rblapack_af, complex*);
-  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 af");
-  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_rwork))
-    rb_raise(rb_eArgError, "rwork (8th argument) must be NArray");
-  if (NA_RANK(rblapack_rwork) != 1)
-    rb_raise(rb_eArgError, "rank of rwork (8th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_rwork) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of rwork must be the same as shape 1 of af");
-  if (NA_TYPE(rblapack_rwork) != NA_SFLOAT)
-    rblapack_rwork = na_change_type(rblapack_rwork, NA_SFLOAT);
-  rwork = NA_PTR_TYPE(rblapack_rwork, real*);
-  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);
-  if (NA_SHAPE1(rblapack_a) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of a must be the same as shape 1 of af");
-  if (NA_TYPE(rblapack_a) != NA_SCOMPLEX)
-    rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
-  a = NA_PTR_TYPE(rblapack_a, complex*);
-  capply = (rblapack_capply == Qtrue);
-  if (!NA_IsNArray(rblapack_ipiv))
-    rb_raise(rb_eArgError, "ipiv (4th argument) must be NArray");
-  if (NA_RANK(rblapack_ipiv) != 1)
-    rb_raise(rb_eArgError, "rank of ipiv (4th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_ipiv) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of ipiv must be the same as shape 1 of af");
-  if (NA_TYPE(rblapack_ipiv) != NA_LINT)
-    rblapack_ipiv = na_change_type(rblapack_ipiv, NA_LINT);
-  ipiv = NA_PTR_TYPE(rblapack_ipiv, integer*);
-  if (!NA_IsNArray(rblapack_work))
-    rb_raise(rb_eArgError, "work (7th argument) must be NArray");
-  if (NA_RANK(rblapack_work) != 1)
-    rb_raise(rb_eArgError, "rank of work (7th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_work) != (2*n))
-    rb_raise(rb_eRuntimeError, "shape 0 of work must be %d", 2*n);
-  if (NA_TYPE(rblapack_work) != NA_SCOMPLEX)
-    rblapack_work = na_change_type(rblapack_work, NA_SCOMPLEX);
-  work = NA_PTR_TYPE(rblapack_work, complex*);
-
-  __out__ = cla_gercond_c_(&trans, &n, a, &lda, af, &ldaf, ipiv, c, &capply, &info, work, rwork);
-
-  rblapack_info = INT2NUM(info);
-  rblapack___out__ = rb_float_new((double)__out__);
-  return rb_ary_new3(2, rblapack_info, rblapack___out__);
-}
-
-void
-init_lapack_cla_gercond_c(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "cla_gercond_c", rblapack_cla_gercond_c, -1);
-}

data/ext/cla_gercond_x.c

@@ -1,130 +0,0 @@
-#include "rb_lapack.h"
-
-extern real cla_gercond_x_(char* trans, integer* n, complex* a, integer* lda, complex* af, integer* ldaf, integer* ipiv, complex* x, integer* info, complex* work, real* rwork);
-
-
-static VALUE
-rblapack_cla_gercond_x(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_trans;
-  char trans; 
-  VALUE rblapack_a;
-  complex *a; 
-  VALUE rblapack_af;
-  complex *af; 
-  VALUE rblapack_ipiv;
-  integer *ipiv; 
-  VALUE rblapack_x;
-  complex *x; 
-  VALUE rblapack_work;
-  complex *work; 
-  VALUE rblapack_rwork;
-  real *rwork; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack___out__;
-  real __out__; 
-
-  integer lda;
-  integer n;
-  integer ldaf;
-
-  VALUE rblapack_options;
-  if (argc > 0 && TYPE(argv[argc-1]) == T_HASH) {
-    argc--;
-    rblapack_options = argv[argc];
-    if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
-      printf("%s\n", "USAGE:\n  info, __out__ = NumRu::Lapack.cla_gercond_x( trans, a, af, ipiv, x, work, rwork, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      REAL FUNCTION CLA_GERCOND_X( TRANS, N, A, LDA, AF, LDAF, IPIV, X, INFO, WORK, RWORK )\n\n*  Purpose\n*  =======\n* \n*     CLA_GERCOND_X computes the infinity norm condition number of\n*     op(A) * diag(X) where X is a COMPLEX vector.\n*\n\n*  Arguments\n*  =========\n*\n*     TRANS   (input) CHARACTER*1\n*     Specifies the form of the system of equations:\n*       = 'N':  A * X = B     (No transpose)\n*       = 'T':  A**T * X = B  (Transpose)\n*       = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)\n*\n*     N       (input) INTEGER\n*     The number of linear equations, i.e., the order of the\n*     matrix A.  N >= 0.\n*\n*     A       (input) COMPLEX array, dimension (LDA,N)\n*     On entry, the N-by-N matrix A.\n*\n*     LDA     (input) INTEGER\n*     The leading dimension of the array A.  LDA >= max(1,N).\n*\n*     AF      (input) COMPLEX array, dimension (LDAF,N)\n*     The factors L and U from the factorization\n*     A = P*L*U as computed by CGETRF.\n*\n*     LDAF    (input) INTEGER\n*     The leading dimension of the array AF.  LDAF >= max(1,N).\n*\n*     IPIV    (input) INTEGER array, dimension (N)\n*     The pivot indices from the factorization A = P*L*U\n*     as computed by CGETRF; row i of the matrix was interchanged\n*     with row IPIV(i).\n*\n*     X       (input) COMPLEX array, dimension (N)\n*     The vector X in the formula op(A) * diag(X).\n*\n*     INFO    (output) INTEGER\n*       = 0:  Successful exit.\n*     i > 0:  The ith argument is invalid.\n*\n*     WORK    (input) COMPLEX array, dimension (2*N).\n*     Workspace.\n*\n*     RWORK   (input) REAL array, dimension (N).\n*     Workspace.\n*\n\n*  =====================================================================\n*\n*     .. Local Scalars ..\n      LOGICAL            NOTRANS\n      INTEGER            KASE\n      REAL               AINVNM, ANORM, TMP\n      INTEGER            I, J\n      COMPLEX            ZDUM\n*     ..\n*     .. Local Arrays ..\n      INTEGER            ISAVE( 3 )\n*     ..\n*     .. External Functions ..\n      LOGICAL            LSAME\n      EXTERNAL           LSAME\n*     ..\n*     .. External Subroutines ..\n      EXTERNAL           CLACN2, CGETRS, XERBLA\n*     ..\n*     .. Intrinsic Functions ..\n      INTRINSIC          ABS, MAX, REAL, AIMAG\n*     ..\n*     .. Statement Functions ..\n      REAL               CABS1\n*     ..\n*     .. Statement Function Definitions ..\n      CABS1( ZDUM ) = ABS( REAL( ZDUM ) ) + ABS( AIMAG( ZDUM ) )\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  info, __out__ = NumRu::Lapack.cla_gercond_x( trans, a, af, ipiv, x, work, rwork, [: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_trans = argv[0];
-  rblapack_a = argv[1];
-  rblapack_af = argv[2];
-  rblapack_ipiv = argv[3];
-  rblapack_x = argv[4];
-  rblapack_work = argv[5];
-  rblapack_rwork = argv[6];
-  if (argc == 7) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  trans = StringValueCStr(rblapack_trans)[0];
-  if (!NA_IsNArray(rblapack_af))
-    rb_raise(rb_eArgError, "af (3th argument) must be NArray");
-  if (NA_RANK(rblapack_af) != 2)
-    rb_raise(rb_eArgError, "rank of af (3th argument) must be %d", 2);
-  ldaf = NA_SHAPE0(rblapack_af);
-  n = NA_SHAPE1(rblapack_af);
-  if (NA_TYPE(rblapack_af) != NA_SCOMPLEX)
-    rblapack_af = na_change_type(rblapack_af, NA_SCOMPLEX);
-  af = NA_PTR_TYPE(rblapack_af, complex*);
-  if (!NA_IsNArray(rblapack_x))
-    rb_raise(rb_eArgError, "x (5th argument) must be NArray");
-  if (NA_RANK(rblapack_x) != 1)
-    rb_raise(rb_eArgError, "rank of x (5th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_x) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of x must be the same as shape 1 of af");
-  if (NA_TYPE(rblapack_x) != NA_SCOMPLEX)
-    rblapack_x = na_change_type(rblapack_x, NA_SCOMPLEX);
-  x = NA_PTR_TYPE(rblapack_x, complex*);
-  if (!NA_IsNArray(rblapack_rwork))
-    rb_raise(rb_eArgError, "rwork (7th argument) must be NArray");
-  if (NA_RANK(rblapack_rwork) != 1)
-    rb_raise(rb_eArgError, "rank of rwork (7th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_rwork) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of rwork must be the same as shape 1 of af");
-  if (NA_TYPE(rblapack_rwork) != NA_SFLOAT)
-    rblapack_rwork = na_change_type(rblapack_rwork, NA_SFLOAT);
-  rwork = NA_PTR_TYPE(rblapack_rwork, real*);
-  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);
-  if (NA_SHAPE1(rblapack_a) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of a must be the same as shape 1 of af");
-  if (NA_TYPE(rblapack_a) != NA_SCOMPLEX)
-    rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
-  a = NA_PTR_TYPE(rblapack_a, complex*);
-  if (!NA_IsNArray(rblapack_ipiv))
-    rb_raise(rb_eArgError, "ipiv (4th argument) must be NArray");
-  if (NA_RANK(rblapack_ipiv) != 1)
-    rb_raise(rb_eArgError, "rank of ipiv (4th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_ipiv) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of ipiv must be the same as shape 1 of af");
-  if (NA_TYPE(rblapack_ipiv) != NA_LINT)
-    rblapack_ipiv = na_change_type(rblapack_ipiv, NA_LINT);
-  ipiv = NA_PTR_TYPE(rblapack_ipiv, integer*);
-  if (!NA_IsNArray(rblapack_work))
-    rb_raise(rb_eArgError, "work (6th argument) must be NArray");
-  if (NA_RANK(rblapack_work) != 1)
-    rb_raise(rb_eArgError, "rank of work (6th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_work) != (2*n))
-    rb_raise(rb_eRuntimeError, "shape 0 of work must be %d", 2*n);
-  if (NA_TYPE(rblapack_work) != NA_SCOMPLEX)
-    rblapack_work = na_change_type(rblapack_work, NA_SCOMPLEX);
-  work = NA_PTR_TYPE(rblapack_work, complex*);
-
-  __out__ = cla_gercond_x_(&trans, &n, a, &lda, af, &ldaf, ipiv, x, &info, work, rwork);
-
-  rblapack_info = INT2NUM(info);
-  rblapack___out__ = rb_float_new((double)__out__);
-  return rb_ary_new3(2, rblapack_info, rblapack___out__);
-}
-
-void
-init_lapack_cla_gercond_x(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "cla_gercond_x", rblapack_cla_gercond_x, -1);
-}