ruby-lapack 1.6 → 1.7

data/ext/slassq.c

@@ -1,70 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slassq_(integer* n, real* x, integer* incx, real* scale, real* sumsq);
-
-
-static VALUE
-rblapack_slassq(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_x;
-  real *x; 
-  VALUE rblapack_incx;
-  integer incx; 
-  VALUE rblapack_scale;
-  real scale; 
-  VALUE rblapack_sumsq;
-  real sumsq; 
-
-  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  scale, sumsq = NumRu::Lapack.slassq( x, incx, scale, sumsq, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLASSQ( N, X, INCX, SCALE, SUMSQ )\n\n*  Purpose\n*  =======\n*\n*  SLASSQ  returns the values  scl  and  smsq  such that\n*\n*     ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq,\n*\n*  where  x( i ) = X( 1 + ( i - 1 )*INCX ). The value of  sumsq  is\n*  assumed to be non-negative and  scl  returns the value\n*\n*     scl = max( scale, abs( x( i ) ) ).\n*\n*  scale and sumsq must be supplied in SCALE and SUMSQ and\n*  scl and smsq are overwritten on SCALE and SUMSQ respectively.\n*\n*  The routine makes only one pass through the vector x.\n*\n\n*  Arguments\n*  =========\n*\n*  N       (input) INTEGER\n*          The number of elements to be used from the vector X.\n*\n*  X       (input) REAL array, dimension (N)\n*          The vector for which a scaled sum of squares is computed.\n*             x( i )  = X( 1 + ( i - 1 )*INCX ), 1 <= i <= n.\n*\n*  INCX    (input) INTEGER\n*          The increment between successive values of the vector X.\n*          INCX > 0.\n*\n*  SCALE   (input/output) REAL\n*          On entry, the value  scale  in the equation above.\n*          On exit, SCALE is overwritten with  scl , the scaling factor\n*          for the sum of squares.\n*\n*  SUMSQ   (input/output) REAL\n*          On entry, the value  sumsq  in the equation above.\n*          On exit, SUMSQ is overwritten with  smsq , the basic sum of\n*          squares from which  scl  has been factored out.\n*\n\n* =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  scale, sumsq = NumRu::Lapack.slassq( x, incx, scale, sumsq, [: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_x = argv[0];
-  rblapack_incx = argv[1];
-  rblapack_scale = argv[2];
-  rblapack_sumsq = argv[3];
-  if (argc == 4) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  if (!NA_IsNArray(rblapack_x))
-    rb_raise(rb_eArgError, "x (1th argument) must be NArray");
-  if (NA_RANK(rblapack_x) != 1)
-    rb_raise(rb_eArgError, "rank of x (1th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_x);
-  if (NA_TYPE(rblapack_x) != NA_SFLOAT)
-    rblapack_x = na_change_type(rblapack_x, NA_SFLOAT);
-  x = NA_PTR_TYPE(rblapack_x, real*);
-  scale = (real)NUM2DBL(rblapack_scale);
-  incx = NUM2INT(rblapack_incx);
-  sumsq = (real)NUM2DBL(rblapack_sumsq);
-
-  slassq_(&n, x, &incx, &scale, &sumsq);
-
-  rblapack_scale = rb_float_new((double)scale);
-  rblapack_sumsq = rb_float_new((double)sumsq);
-  return rb_ary_new3(2, rblapack_scale, rblapack_sumsq);
-}
-
-void
-init_lapack_slassq(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slassq", rblapack_slassq, -1);
-}

data/ext/slasv2.c

@@ -1,74 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slasv2_(real* f, real* g, real* h, real* ssmin, real* ssmax, real* snr, real* csr, real* snl, real* csl);
-
-
-static VALUE
-rblapack_slasv2(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_f;
-  real f; 
-  VALUE rblapack_g;
-  real g; 
-  VALUE rblapack_h;
-  real h; 
-  VALUE rblapack_ssmin;
-  real ssmin; 
-  VALUE rblapack_ssmax;
-  real ssmax; 
-  VALUE rblapack_snr;
-  real snr; 
-  VALUE rblapack_csr;
-  real csr; 
-  VALUE rblapack_snl;
-  real snl; 
-  VALUE rblapack_csl;
-  real csl; 
-
-
-  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  ssmin, ssmax, snr, csr, snl, csl = NumRu::Lapack.slasv2( f, g, h, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLASV2( F, G, H, SSMIN, SSMAX, SNR, CSR, SNL, CSL )\n\n*  Purpose\n*  =======\n*\n*  SLASV2 computes the singular value decomposition of a 2-by-2\n*  triangular matrix\n*     [  F   G  ]\n*     [  0   H  ].\n*  On return, abs(SSMAX) is the larger singular value, abs(SSMIN) is the\n*  smaller singular value, and (CSL,SNL) and (CSR,SNR) are the left and\n*  right singular vectors for abs(SSMAX), giving the decomposition\n*\n*     [ CSL  SNL ] [  F   G  ] [ CSR -SNR ]  =  [ SSMAX   0   ]\n*     [-SNL  CSL ] [  0   H  ] [ SNR  CSR ]     [  0    SSMIN ].\n*\n\n*  Arguments\n*  =========\n*\n*  F       (input) REAL\n*          The (1,1) element of the 2-by-2 matrix.\n*\n*  G       (input) REAL\n*          The (1,2) element of the 2-by-2 matrix.\n*\n*  H       (input) REAL\n*          The (2,2) element of the 2-by-2 matrix.\n*\n*  SSMIN   (output) REAL\n*          abs(SSMIN) is the smaller singular value.\n*\n*  SSMAX   (output) REAL\n*          abs(SSMAX) is the larger singular value.\n*\n*  SNL     (output) REAL\n*  CSL     (output) REAL\n*          The vector (CSL, SNL) is a unit left singular vector for the\n*          singular value abs(SSMAX).\n*\n*  SNR     (output) REAL\n*  CSR     (output) REAL\n*          The vector (CSR, SNR) is a unit right singular vector for the\n*          singular value abs(SSMAX).\n*\n\n*  Further Details\n*  ===============\n*\n*  Any input parameter may be aliased with any output parameter.\n*\n*  Barring over/underflow and assuming a guard digit in subtraction, all\n*  output quantities are correct to within a few units in the last\n*  place (ulps).\n*\n*  In IEEE arithmetic, the code works correctly if one matrix element is\n*  infinite.\n*\n*  Overflow will not occur unless the largest singular value itself\n*  overflows or is within a few ulps of overflow. (On machines with\n*  partial overflow, like the Cray, overflow may occur if the largest\n*  singular value is within a factor of 2 of overflow.)\n*\n*  Underflow is harmless if underflow is gradual. Otherwise, results\n*  may correspond to a matrix modified by perturbations of size near\n*  the underflow threshold.\n*\n* =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  ssmin, ssmax, snr, csr, snl, csl = NumRu::Lapack.slasv2( f, g, h, [: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_f = argv[0];
-  rblapack_g = argv[1];
-  rblapack_h = argv[2];
-  if (argc == 3) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  f = (real)NUM2DBL(rblapack_f);
-  h = (real)NUM2DBL(rblapack_h);
-  g = (real)NUM2DBL(rblapack_g);
-
-  slasv2_(&f, &g, &h, &ssmin, &ssmax, &snr, &csr, &snl, &csl);
-
-  rblapack_ssmin = rb_float_new((double)ssmin);
-  rblapack_ssmax = rb_float_new((double)ssmax);
-  rblapack_snr = rb_float_new((double)snr);
-  rblapack_csr = rb_float_new((double)csr);
-  rblapack_snl = rb_float_new((double)snl);
-  rblapack_csl = rb_float_new((double)csl);
-  return rb_ary_new3(6, rblapack_ssmin, rblapack_ssmax, rblapack_snr, rblapack_csr, rblapack_snl, rblapack_csl);
-}
-
-void
-init_lapack_slasv2(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slasv2", rblapack_slasv2, -1);
-}

data/ext/slaswp.c

@@ -1,94 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slaswp_(integer* n, real* a, integer* lda, integer* k1, integer* k2, integer* ipiv, integer* incx);
-
-
-static VALUE
-rblapack_slaswp(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_a;
-  real *a; 
-  VALUE rblapack_k1;
-  integer k1; 
-  VALUE rblapack_k2;
-  integer k2; 
-  VALUE rblapack_ipiv;
-  integer *ipiv; 
-  VALUE rblapack_incx;
-  integer incx; 
-  VALUE rblapack_a_out__;
-  real *a_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  a = NumRu::Lapack.slaswp( a, k1, k2, ipiv, incx, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLASWP( N, A, LDA, K1, K2, IPIV, INCX )\n\n*  Purpose\n*  =======\n*\n*  SLASWP performs a series of row interchanges on the matrix A.\n*  One row interchange is initiated for each of rows K1 through K2 of A.\n*\n\n*  Arguments\n*  =========\n*\n*  N       (input) INTEGER\n*          The number of columns of the matrix A.\n*\n*  A       (input/output) REAL array, dimension (LDA,N)\n*          On entry, the matrix of column dimension N to which the row\n*          interchanges will be applied.\n*          On exit, the permuted matrix.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A.\n*\n*  K1      (input) INTEGER\n*          The first element of IPIV for which a row interchange will\n*          be done.\n*\n*  K2      (input) INTEGER\n*          The last element of IPIV for which a row interchange will\n*          be done.\n*\n*  IPIV    (input) INTEGER array, dimension (K2*abs(INCX))\n*          The vector of pivot indices.  Only the elements in positions\n*          K1 through K2 of IPIV are accessed.\n*          IPIV(K) = L implies rows K and L are to be interchanged.\n*\n*  INCX    (input) INTEGER\n*          The increment between successive values of IPIV.  If IPIV\n*          is negative, the pivots are applied in reverse order.\n*\n\n*  Further Details\n*  ===============\n*\n*  Modified by\n*   R. C. Whaley, Computer Science Dept., Univ. of Tenn., Knoxville, USA\n*\n* =====================================================================\n*\n*     .. Local Scalars ..\n      INTEGER            I, I1, I2, INC, IP, IX, IX0, J, K, N32\n      REAL               TEMP\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  a = NumRu::Lapack.slaswp( a, k1, k2, ipiv, incx, [: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_a = argv[0];
-  rblapack_k1 = argv[1];
-  rblapack_k2 = argv[2];
-  rblapack_ipiv = argv[3];
-  rblapack_incx = argv[4];
-  if (argc == 5) {
-  } 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_SFLOAT)
-    rblapack_a = na_change_type(rblapack_a, NA_SFLOAT);
-  a = NA_PTR_TYPE(rblapack_a, real*);
-  k2 = NUM2INT(rblapack_k2);
-  incx = NUM2INT(rblapack_incx);
-  k1 = NUM2INT(rblapack_k1);
-  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) != (k2*abs(incx)))
-    rb_raise(rb_eRuntimeError, "shape 0 of ipiv must be %d", k2*abs(incx));
-  if (NA_TYPE(rblapack_ipiv) != NA_LINT)
-    rblapack_ipiv = na_change_type(rblapack_ipiv, NA_LINT);
-  ipiv = NA_PTR_TYPE(rblapack_ipiv, integer*);
-  {
-    int shape[2];
-    shape[0] = lda;
-    shape[1] = n;
-    rblapack_a_out__ = na_make_object(NA_SFLOAT, 2, shape, cNArray);
-  }
-  a_out__ = NA_PTR_TYPE(rblapack_a_out__, real*);
-  MEMCPY(a_out__, a, real, NA_TOTAL(rblapack_a));
-  rblapack_a = rblapack_a_out__;
-  a = a_out__;
-
-  slaswp_(&n, a, &lda, &k1, &k2, ipiv, &incx);
-
-  return rblapack_a;
-}
-
-void
-init_lapack_slaswp(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slaswp", rblapack_slaswp, -1);
-}

data/ext/slasy2.c

@@ -1,126 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slasy2_(logical* ltranl, logical* ltranr, integer* isgn, integer* n1, integer* n2, real* tl, integer* ldtl, real* tr, integer* ldtr, real* b, integer* ldb, real* scale, real* x, integer* ldx, real* xnorm, integer* info);
-
-
-static VALUE
-rblapack_slasy2(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_ltranl;
-  logical ltranl; 
-  VALUE rblapack_ltranr;
-  logical ltranr; 
-  VALUE rblapack_isgn;
-  integer isgn; 
-  VALUE rblapack_n1;
-  integer n1; 
-  VALUE rblapack_n2;
-  integer n2; 
-  VALUE rblapack_tl;
-  real *tl; 
-  VALUE rblapack_tr;
-  real *tr; 
-  VALUE rblapack_b;
-  real *b; 
-  VALUE rblapack_scale;
-  real scale; 
-  VALUE rblapack_x;
-  real *x; 
-  VALUE rblapack_xnorm;
-  real xnorm; 
-  VALUE rblapack_info;
-  integer info; 
-
-  integer ldtl;
-  integer ldtr;
-  integer ldb;
-  integer ldx;
-
-  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  scale, x, xnorm, info = NumRu::Lapack.slasy2( ltranl, ltranr, isgn, n1, n2, tl, tr, b, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLASY2( LTRANL, LTRANR, ISGN, N1, N2, TL, LDTL, TR, LDTR, B, LDB, SCALE, X, LDX, XNORM, INFO )\n\n*  Purpose\n*  =======\n*\n*  SLASY2 solves for the N1 by N2 matrix X, 1 <= N1,N2 <= 2, in\n*\n*         op(TL)*X + ISGN*X*op(TR) = SCALE*B,\n*\n*  where TL is N1 by N1, TR is N2 by N2, B is N1 by N2, and ISGN = 1 or\n*  -1.  op(T) = T or T', where T' denotes the transpose of T.\n*\n\n*  Arguments\n*  =========\n*\n*  LTRANL  (input) LOGICAL\n*          On entry, LTRANL specifies the op(TL):\n*             = .FALSE., op(TL) = TL,\n*             = .TRUE., op(TL) = TL'.\n*\n*  LTRANR  (input) LOGICAL\n*          On entry, LTRANR specifies the op(TR):\n*            = .FALSE., op(TR) = TR,\n*            = .TRUE., op(TR) = TR'.\n*\n*  ISGN    (input) INTEGER\n*          On entry, ISGN specifies the sign of the equation\n*          as described before. ISGN may only be 1 or -1.\n*\n*  N1      (input) INTEGER\n*          On entry, N1 specifies the order of matrix TL.\n*          N1 may only be 0, 1 or 2.\n*\n*  N2      (input) INTEGER\n*          On entry, N2 specifies the order of matrix TR.\n*          N2 may only be 0, 1 or 2.\n*\n*  TL      (input) REAL array, dimension (LDTL,2)\n*          On entry, TL contains an N1 by N1 matrix.\n*\n*  LDTL    (input) INTEGER\n*          The leading dimension of the matrix TL. LDTL >= max(1,N1).\n*\n*  TR      (input) REAL array, dimension (LDTR,2)\n*          On entry, TR contains an N2 by N2 matrix.\n*\n*  LDTR    (input) INTEGER\n*          The leading dimension of the matrix TR. LDTR >= max(1,N2).\n*\n*  B       (input) REAL array, dimension (LDB,2)\n*          On entry, the N1 by N2 matrix B contains the right-hand\n*          side of the equation.\n*\n*  LDB     (input) INTEGER\n*          The leading dimension of the matrix B. LDB >= max(1,N1).\n*\n*  SCALE   (output) REAL\n*          On exit, SCALE contains the scale factor. SCALE is chosen\n*          less than or equal to 1 to prevent the solution overflowing.\n*\n*  X       (output) REAL array, dimension (LDX,2)\n*          On exit, X contains the N1 by N2 solution.\n*\n*  LDX     (input) INTEGER\n*          The leading dimension of the matrix X. LDX >= max(1,N1).\n*\n*  XNORM   (output) REAL\n*          On exit, XNORM is the infinity-norm of the solution.\n*\n*  INFO    (output) INTEGER\n*          On exit, INFO is set to\n*             0: successful exit.\n*             1: TL and TR have too close eigenvalues, so TL or\n*                TR is perturbed to get a nonsingular equation.\n*          NOTE: In the interests of speed, this routine does not\n*                check the inputs for errors.\n*\n\n* =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  scale, x, xnorm, info = NumRu::Lapack.slasy2( ltranl, ltranr, isgn, n1, n2, tl, tr, b, [: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_ltranl = argv[0];
-  rblapack_ltranr = argv[1];
-  rblapack_isgn = argv[2];
-  rblapack_n1 = argv[3];
-  rblapack_n2 = argv[4];
-  rblapack_tl = argv[5];
-  rblapack_tr = argv[6];
-  rblapack_b = argv[7];
-  if (argc == 8) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  ltranl = (rblapack_ltranl == Qtrue);
-  isgn = NUM2INT(rblapack_isgn);
-  n2 = NUM2INT(rblapack_n2);
-  if (!NA_IsNArray(rblapack_tr))
-    rb_raise(rb_eArgError, "tr (7th argument) must be NArray");
-  if (NA_RANK(rblapack_tr) != 2)
-    rb_raise(rb_eArgError, "rank of tr (7th argument) must be %d", 2);
-  ldtr = NA_SHAPE0(rblapack_tr);
-  if (NA_SHAPE1(rblapack_tr) != (2))
-    rb_raise(rb_eRuntimeError, "shape 1 of tr must be %d", 2);
-  if (NA_TYPE(rblapack_tr) != NA_SFLOAT)
-    rblapack_tr = na_change_type(rblapack_tr, NA_SFLOAT);
-  tr = NA_PTR_TYPE(rblapack_tr, real*);
-  ltranr = (rblapack_ltranr == Qtrue);
-  if (!NA_IsNArray(rblapack_tl))
-    rb_raise(rb_eArgError, "tl (6th argument) must be NArray");
-  if (NA_RANK(rblapack_tl) != 2)
-    rb_raise(rb_eArgError, "rank of tl (6th argument) must be %d", 2);
-  ldtl = NA_SHAPE0(rblapack_tl);
-  if (NA_SHAPE1(rblapack_tl) != (2))
-    rb_raise(rb_eRuntimeError, "shape 1 of tl must be %d", 2);
-  if (NA_TYPE(rblapack_tl) != NA_SFLOAT)
-    rblapack_tl = na_change_type(rblapack_tl, NA_SFLOAT);
-  tl = NA_PTR_TYPE(rblapack_tl, real*);
-  n1 = NUM2INT(rblapack_n1);
-  ldx = MAX(1,n1);
-  if (!NA_IsNArray(rblapack_b))
-    rb_raise(rb_eArgError, "b (8th argument) must be NArray");
-  if (NA_RANK(rblapack_b) != 2)
-    rb_raise(rb_eArgError, "rank of b (8th argument) must be %d", 2);
-  ldb = NA_SHAPE0(rblapack_b);
-  if (NA_SHAPE1(rblapack_b) != (2))
-    rb_raise(rb_eRuntimeError, "shape 1 of b must be %d", 2);
-  if (NA_TYPE(rblapack_b) != NA_SFLOAT)
-    rblapack_b = na_change_type(rblapack_b, NA_SFLOAT);
-  b = NA_PTR_TYPE(rblapack_b, real*);
-  {
-    int shape[2];
-    shape[0] = ldx;
-    shape[1] = 2;
-    rblapack_x = na_make_object(NA_SFLOAT, 2, shape, cNArray);
-  }
-  x = NA_PTR_TYPE(rblapack_x, real*);
-
-  slasy2_(&ltranl, &ltranr, &isgn, &n1, &n2, tl, &ldtl, tr, &ldtr, b, &ldb, &scale, x, &ldx, &xnorm, &info);
-
-  rblapack_scale = rb_float_new((double)scale);
-  rblapack_xnorm = rb_float_new((double)xnorm);
-  rblapack_info = INT2NUM(info);
-  return rb_ary_new3(4, rblapack_scale, rblapack_x, rblapack_xnorm, rblapack_info);
-}
-
-void
-init_lapack_slasy2(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slasy2", rblapack_slasy2, -1);
-}

data/ext/slasyf.c

@@ -1,97 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID slasyf_(char* uplo, integer* n, integer* nb, integer* kb, real* a, integer* lda, integer* ipiv, real* w, integer* ldw, integer* info);
-
-
-static VALUE
-rblapack_slasyf(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_uplo;
-  char uplo; 
-  VALUE rblapack_nb;
-  integer nb; 
-  VALUE rblapack_a;
-  real *a; 
-  VALUE rblapack_kb;
-  integer kb; 
-  VALUE rblapack_ipiv;
-  integer *ipiv; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack_a_out__;
-  real *a_out__;
-  real *w;
-
-  integer lda;
-  integer n;
-  integer ldw;
-
-  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  kb, ipiv, info, a = NumRu::Lapack.slasyf( uplo, nb, a, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLASYF( UPLO, N, NB, KB, A, LDA, IPIV, W, LDW, INFO )\n\n*  Purpose\n*  =======\n*\n*  SLASYF computes a partial factorization of a real symmetric matrix A\n*  using the Bunch-Kaufman diagonal pivoting method. The partial\n*  factorization has the form:\n*\n*  A  =  ( I  U12 ) ( A11  0  ) (  I    0   )  if UPLO = 'U', or:\n*        ( 0  U22 ) (  0   D  ) ( U12' U22' )\n*\n*  A  =  ( L11  0 ) (  D   0  ) ( L11' L21' )  if UPLO = 'L'\n*        ( L21  I ) (  0  A22 ) (  0    I   )\n*\n*  where the order of D is at most NB. The actual order is returned in\n*  the argument KB, and is either NB or NB-1, or N if N <= NB.\n*\n*  SLASYF is an auxiliary routine called by SSYTRF. It uses blocked code\n*  (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or\n*  A22 (if UPLO = 'L').\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*  NB      (input) INTEGER\n*          The maximum number of columns of the matrix A that should be\n*          factored.  NB should be at least 2 to allow for 2-by-2 pivot\n*          blocks.\n*\n*  KB      (output) INTEGER\n*          The number of columns of A that were actually factored.\n*          KB is either NB-1 or NB, or N if N <= NB.\n*\n*  A       (input/output) REAL array, dimension (LDA,N)\n*          On entry, the symmetric matrix A.  If UPLO = 'U', the leading\n*          n-by-n upper triangular part of A contains the upper\n*          triangular part of the matrix A, and the strictly lower\n*          triangular part of A is not referenced.  If UPLO = 'L', the\n*          leading n-by-n lower triangular part of A contains the lower\n*          triangular part of the matrix A, and the strictly upper\n*          triangular part of A is not referenced.\n*          On exit, A contains details of the partial factorization.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A.  LDA >= max(1,N).\n*\n*  IPIV    (output) INTEGER array, dimension (N)\n*          Details of the interchanges and the block structure of D.\n*          If UPLO = 'U', only the last KB elements of IPIV are set;\n*          if UPLO = 'L', only the first KB elements are set.\n*\n*          If IPIV(k) > 0, then rows and columns k and IPIV(k) were\n*          interchanged and D(k,k) is a 1-by-1 diagonal block.\n*          If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and\n*          columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)\n*          is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =\n*          IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were\n*          interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block.\n*\n*  W       (workspace) REAL array, dimension (LDW,NB)\n*\n*  LDW     (input) INTEGER\n*          The leading dimension of the array W.  LDW >= max(1,N).\n*\n*  INFO    (output) INTEGER\n*          = 0: successful exit\n*          > 0: if INFO = k, D(k,k) is exactly zero.  The factorization\n*               has been completed, but the block diagonal matrix D is\n*               exactly singular.\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  kb, ipiv, info, a = NumRu::Lapack.slasyf( uplo, nb, a, [: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_uplo = argv[0];
-  rblapack_nb = argv[1];
-  rblapack_a = argv[2];
-  if (argc == 3) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  uplo = StringValueCStr(rblapack_uplo)[0];
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (3th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (3th 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*);
-  nb = NUM2INT(rblapack_nb);
-  ldw = MAX(1,n);
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_ipiv = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  ipiv = NA_PTR_TYPE(rblapack_ipiv, integer*);
-  {
-    int shape[2];
-    shape[0] = lda;
-    shape[1] = n;
-    rblapack_a_out__ = na_make_object(NA_SFLOAT, 2, shape, cNArray);
-  }
-  a_out__ = NA_PTR_TYPE(rblapack_a_out__, real*);
-  MEMCPY(a_out__, a, real, NA_TOTAL(rblapack_a));
-  rblapack_a = rblapack_a_out__;
-  a = a_out__;
-  w = ALLOC_N(real, (ldw)*(MAX(1,nb)));
-
-  slasyf_(&uplo, &n, &nb, &kb, a, &lda, ipiv, w, &ldw, &info);
-
-  free(w);
-  rblapack_kb = INT2NUM(kb);
-  rblapack_info = INT2NUM(info);
-  return rb_ary_new3(4, rblapack_kb, rblapack_ipiv, rblapack_info, rblapack_a);
-}
-
-void
-init_lapack_slasyf(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "slasyf", rblapack_slasyf, -1);
-}