ruby-lapack 1.7 → 1.7.1

data/ext/slasd1.c

@@ -0,0 +1,160 @@
+#include "rb_lapack.h"
+
+extern VOID slasd1_(integer* nl, integer* nr, integer* sqre, real* d, real* alpha, real* beta, real* u, integer* ldu, real* vt, integer* ldvt, integer* idxq, integer* iwork, real* work, integer* info);
+
+
+static VALUE
+rblapack_slasd1(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_nl;
+  integer nl; 
+  VALUE rblapack_nr;
+  integer nr; 
+  VALUE rblapack_sqre;
+  integer sqre; 
+  VALUE rblapack_d;
+  real *d; 
+  VALUE rblapack_alpha;
+  real alpha; 
+  VALUE rblapack_beta;
+  real beta; 
+  VALUE rblapack_u;
+  real *u; 
+  VALUE rblapack_vt;
+  real *vt; 
+  VALUE rblapack_idxq;
+  integer *idxq; 
+  VALUE rblapack_info;
+  integer info; 
+  VALUE rblapack_d_out__;
+  real *d_out__;
+  VALUE rblapack_u_out__;
+  real *u_out__;
+  VALUE rblapack_vt_out__;
+  real *vt_out__;
+  integer *iwork;
+  real *work;
+
+  integer ldu;
+  integer n;
+  integer ldvt;
+  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  idxq, info, d, alpha, beta, u, vt = NumRu::Lapack.slasd1( nl, nr, sqre, d, alpha, beta, u, vt, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLASD1( NL, NR, SQRE, D, ALPHA, BETA, U, LDU, VT, LDVT, IDXQ, IWORK, WORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  SLASD1 computes the SVD of an upper bidiagonal N-by-M matrix B,\n*  where N = NL + NR + 1 and M = N + SQRE. SLASD1 is called from SLASD0.\n*\n*  A related subroutine SLASD7 handles the case in which the singular\n*  values (and the singular vectors in factored form) are desired.\n*\n*  SLASD1 computes the SVD as follows:\n*\n*                ( D1(in)  0    0     0 )\n*    B = U(in) * (   Z1'   a   Z2'    b ) * VT(in)\n*                (   0     0   D2(in) 0 )\n*\n*      = U(out) * ( D(out) 0) * VT(out)\n*\n*  where Z' = (Z1' a Z2' b) = u' VT', and u is a vector of dimension M\n*  with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros\n*  elsewhere; and the entry b is empty if SQRE = 0.\n*\n*  The left singular vectors of the original matrix are stored in U, and\n*  the transpose of the right singular vectors are stored in VT, and the\n*  singular values are in D.  The algorithm consists of three stages:\n*\n*     The first stage consists of deflating the size of the problem\n*     when there are multiple singular values or when there are zeros in\n*     the Z vector.  For each such occurence the dimension of the\n*     secular equation problem is reduced by one.  This stage is\n*     performed by the routine SLASD2.\n*\n*     The second stage consists of calculating the updated\n*     singular values. This is done by finding the square roots of the\n*     roots of the secular equation via the routine SLASD4 (as called\n*     by SLASD3). This routine also calculates the singular vectors of\n*     the current problem.\n*\n*     The final stage consists of computing the updated singular vectors\n*     directly using the updated singular values.  The singular vectors\n*     for the current problem are multiplied with the singular vectors\n*     from the overall problem.\n*\n\n*  Arguments\n*  =========\n*\n*  NL     (input) INTEGER\n*         The row dimension of the upper block.  NL >= 1.\n*\n*  NR     (input) INTEGER\n*         The row dimension of the lower block.  NR >= 1.\n*\n*  SQRE   (input) INTEGER\n*         = 0: the lower block is an NR-by-NR square matrix.\n*         = 1: the lower block is an NR-by-(NR+1) rectangular matrix.\n*\n*         The bidiagonal matrix has row dimension N = NL + NR + 1,\n*         and column dimension M = N + SQRE.\n*\n*  D      (input/output) REAL array, dimension (NL+NR+1).\n*         N = NL+NR+1\n*         On entry D(1:NL,1:NL) contains the singular values of the\n*         upper block; and D(NL+2:N) contains the singular values of\n*         the lower block. On exit D(1:N) contains the singular values\n*         of the modified matrix.\n*\n*  ALPHA  (input/output) REAL\n*         Contains the diagonal element associated with the added row.\n*\n*  BETA   (input/output) REAL\n*         Contains the off-diagonal element associated with the added\n*         row.\n*\n*  U      (input/output) REAL array, dimension (LDU,N)\n*         On entry U(1:NL, 1:NL) contains the left singular vectors of\n*         the upper block; U(NL+2:N, NL+2:N) contains the left singular\n*         vectors of the lower block. On exit U contains the left\n*         singular vectors of the bidiagonal matrix.\n*\n*  LDU    (input) INTEGER\n*         The leading dimension of the array U.  LDU >= max( 1, N ).\n*\n*  VT     (input/output) REAL array, dimension (LDVT,M)\n*         where M = N + SQRE.\n*         On entry VT(1:NL+1, 1:NL+1)' contains the right singular\n*         vectors of the upper block; VT(NL+2:M, NL+2:M)' contains\n*         the right singular vectors of the lower block. On exit\n*         VT' contains the right singular vectors of the\n*         bidiagonal matrix.\n*\n*  LDVT   (input) INTEGER\n*         The leading dimension of the array VT.  LDVT >= max( 1, M ).\n*\n*  IDXQ  (output) INTEGER array, dimension (N)\n*         This contains the permutation which will reintegrate the\n*         subproblem just solved back into sorted order, i.e.\n*         D( IDXQ( I = 1, N ) ) will be in ascending order.\n*\n*  IWORK  (workspace) INTEGER array, dimension (4*N)\n*\n*  WORK   (workspace) REAL array, dimension (3*M**2+2*M)\n*\n*  INFO   (output) INTEGER\n*          = 0:  successful exit.\n*          < 0:  if INFO = -i, the i-th argument had an illegal value.\n*          > 0:  if INFO = 1, a singular value did not converge\n*\n\n*  Further Details\n*  ===============\n*\n*  Based on contributions by\n*     Ming Gu and Huan Ren, Computer Science Division, University of\n*     California at Berkeley, USA\n*\n*  =====================================================================\n*\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  idxq, info, d, alpha, beta, u, vt = NumRu::Lapack.slasd1( nl, nr, sqre, d, alpha, beta, u, vt, [: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_nl = argv[0];
+  rblapack_nr = argv[1];
+  rblapack_sqre = argv[2];
+  rblapack_d = argv[3];
+  rblapack_alpha = argv[4];
+  rblapack_beta = argv[5];
+  rblapack_u = argv[6];
+  rblapack_vt = argv[7];
+  if (argc == 8) {
+  } else if (rblapack_options != Qnil) {
+  } else {
+  }
+
+  nl = NUM2INT(rblapack_nl);
+  sqre = NUM2INT(rblapack_sqre);
+  alpha = (real)NUM2DBL(rblapack_alpha);
+  if (!NA_IsNArray(rblapack_u))
+    rb_raise(rb_eArgError, "u (7th argument) must be NArray");
+  if (NA_RANK(rblapack_u) != 2)
+    rb_raise(rb_eArgError, "rank of u (7th argument) must be %d", 2);
+  ldu = NA_SHAPE0(rblapack_u);
+  n = NA_SHAPE1(rblapack_u);
+  if (NA_TYPE(rblapack_u) != NA_SFLOAT)
+    rblapack_u = na_change_type(rblapack_u, NA_SFLOAT);
+  u = NA_PTR_TYPE(rblapack_u, real*);
+  m = n + sqre;
+  nr = NUM2INT(rblapack_nr);
+  beta = (real)NUM2DBL(rblapack_beta);
+  if (!NA_IsNArray(rblapack_d))
+    rb_raise(rb_eArgError, "d (4th argument) must be NArray");
+  if (NA_RANK(rblapack_d) != 1)
+    rb_raise(rb_eArgError, "rank of d (4th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_d) != (nl+nr+1))
+    rb_raise(rb_eRuntimeError, "shape 0 of d must be %d", nl+nr+1);
+  if (NA_TYPE(rblapack_d) != NA_SFLOAT)
+    rblapack_d = na_change_type(rblapack_d, NA_SFLOAT);
+  d = NA_PTR_TYPE(rblapack_d, real*);
+  if (!NA_IsNArray(rblapack_vt))
+    rb_raise(rb_eArgError, "vt (8th argument) must be NArray");
+  if (NA_RANK(rblapack_vt) != 2)
+    rb_raise(rb_eArgError, "rank of vt (8th argument) must be %d", 2);
+  ldvt = NA_SHAPE0(rblapack_vt);
+  if (NA_SHAPE1(rblapack_vt) != m)
+    rb_raise(rb_eRuntimeError, "shape 1 of vt must be n + sqre");
+  if (NA_TYPE(rblapack_vt) != NA_SFLOAT)
+    rblapack_vt = na_change_type(rblapack_vt, NA_SFLOAT);
+  vt = NA_PTR_TYPE(rblapack_vt, real*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_idxq = na_make_object(NA_LINT, 1, shape, cNArray);
+  }
+  idxq = NA_PTR_TYPE(rblapack_idxq, integer*);
+  {
+    na_shape_t shape[1];
+    shape[0] = nl+nr+1;
+    rblapack_d_out__ = na_make_object(NA_SFLOAT, 1, shape, cNArray);
+  }
+  d_out__ = NA_PTR_TYPE(rblapack_d_out__, real*);
+  MEMCPY(d_out__, d, real, NA_TOTAL(rblapack_d));
+  rblapack_d = rblapack_d_out__;
+  d = d_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = ldu;
+    shape[1] = n;
+    rblapack_u_out__ = na_make_object(NA_SFLOAT, 2, shape, cNArray);
+  }
+  u_out__ = NA_PTR_TYPE(rblapack_u_out__, real*);
+  MEMCPY(u_out__, u, real, NA_TOTAL(rblapack_u));
+  rblapack_u = rblapack_u_out__;
+  u = u_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = ldvt;
+    shape[1] = m;
+    rblapack_vt_out__ = na_make_object(NA_SFLOAT, 2, shape, cNArray);
+  }
+  vt_out__ = NA_PTR_TYPE(rblapack_vt_out__, real*);
+  MEMCPY(vt_out__, vt, real, NA_TOTAL(rblapack_vt));
+  rblapack_vt = rblapack_vt_out__;
+  vt = vt_out__;
+  iwork = ALLOC_N(integer, (4*n));
+  work = ALLOC_N(real, (3*pow(m,2)+2*m));
+
+  slasd1_(&nl, &nr, &sqre, d, &alpha, &beta, u, &ldu, vt, &ldvt, idxq, iwork, work, &info);
+
+  free(iwork);
+  free(work);
+  rblapack_info = INT2NUM(info);
+  rblapack_alpha = rb_float_new((double)alpha);
+  rblapack_beta = rb_float_new((double)beta);
+  return rb_ary_new3(7, rblapack_idxq, rblapack_info, rblapack_d, rblapack_alpha, rblapack_beta, rblapack_u, rblapack_vt);
+}
+
+void
+init_lapack_slasd1(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "slasd1", rblapack_slasd1, -1);
+}

data/ext/slasd2.c

@@ -0,0 +1,228 @@
+#include "rb_lapack.h"
+
+extern VOID slasd2_(integer* nl, integer* nr, integer* sqre, integer* k, real* d, real* z, real* alpha, real* beta, real* u, integer* ldu, real* vt, integer* ldvt, real* dsigma, real* u2, integer* ldu2, real* vt2, integer* ldvt2, integer* idxp, integer* idx, integer* idxc, integer* idxq, integer* coltyp, integer* info);
+
+
+static VALUE
+rblapack_slasd2(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_nl;
+  integer nl; 
+  VALUE rblapack_nr;
+  integer nr; 
+  VALUE rblapack_sqre;
+  integer sqre; 
+  VALUE rblapack_d;
+  real *d; 
+  VALUE rblapack_alpha;
+  real alpha; 
+  VALUE rblapack_beta;
+  real beta; 
+  VALUE rblapack_u;
+  real *u; 
+  VALUE rblapack_vt;
+  real *vt; 
+  VALUE rblapack_idxq;
+  integer *idxq; 
+  VALUE rblapack_k;
+  integer k; 
+  VALUE rblapack_z;
+  real *z; 
+  VALUE rblapack_dsigma;
+  real *dsigma; 
+  VALUE rblapack_u2;
+  real *u2; 
+  VALUE rblapack_vt2;
+  real *vt2; 
+  VALUE rblapack_idxc;
+  integer *idxc; 
+  VALUE rblapack_coltyp;
+  integer *coltyp; 
+  VALUE rblapack_info;
+  integer info; 
+  VALUE rblapack_d_out__;
+  real *d_out__;
+  VALUE rblapack_u_out__;
+  real *u_out__;
+  VALUE rblapack_vt_out__;
+  real *vt_out__;
+  VALUE rblapack_idxq_out__;
+  integer *idxq_out__;
+  integer *idxp;
+  integer *idx;
+
+  integer n;
+  integer ldu;
+  integer ldvt;
+  integer m;
+  integer ldu2;
+  integer ldvt2;
+
+  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  k, z, dsigma, u2, vt2, idxc, coltyp, info, d, u, vt, idxq = NumRu::Lapack.slasd2( nl, nr, sqre, d, alpha, beta, u, vt, idxq, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLASD2( NL, NR, SQRE, K, D, Z, ALPHA, BETA, U, LDU, VT, LDVT, DSIGMA, U2, LDU2, VT2, LDVT2, IDXP, IDX, IDXC, IDXQ, COLTYP, INFO )\n\n*  Purpose\n*  =======\n*\n*  SLASD2 merges the two sets of singular values together into a single\n*  sorted set.  Then it tries to deflate the size of the problem.\n*  There are two ways in which deflation can occur:  when two or more\n*  singular values are close together or if there is a tiny entry in the\n*  Z vector.  For each such occurrence the order of the related secular\n*  equation problem is reduced by one.\n*\n*  SLASD2 is called from SLASD1.\n*\n\n*  Arguments\n*  =========\n*\n*  NL     (input) INTEGER\n*         The row dimension of the upper block.  NL >= 1.\n*\n*  NR     (input) INTEGER\n*         The row dimension of the lower block.  NR >= 1.\n*\n*  SQRE   (input) INTEGER\n*         = 0: the lower block is an NR-by-NR square matrix.\n*         = 1: the lower block is an NR-by-(NR+1) rectangular matrix.\n*\n*         The bidiagonal matrix has N = NL + NR + 1 rows and\n*         M = N + SQRE >= N columns.\n*\n*  K      (output) INTEGER\n*         Contains the dimension of the non-deflated matrix,\n*         This is the order of the related secular equation. 1 <= K <=N.\n*\n*  D      (input/output) REAL array, dimension (N)\n*         On entry D contains the singular values of the two submatrices\n*         to be combined.  On exit D contains the trailing (N-K) updated\n*         singular values (those which were deflated) sorted into\n*         increasing order.\n*\n*  Z      (output) REAL array, dimension (N)\n*         On exit Z contains the updating row vector in the secular\n*         equation.\n*\n*  ALPHA  (input) REAL\n*         Contains the diagonal element associated with the added row.\n*\n*  BETA   (input) REAL\n*         Contains the off-diagonal element associated with the added\n*         row.\n*\n*  U      (input/output) REAL array, dimension (LDU,N)\n*         On entry U contains the left singular vectors of two\n*         submatrices in the two square blocks with corners at (1,1),\n*         (NL, NL), and (NL+2, NL+2), (N,N).\n*         On exit U contains the trailing (N-K) updated left singular\n*         vectors (those which were deflated) in its last N-K columns.\n*\n*  LDU    (input) INTEGER\n*         The leading dimension of the array U.  LDU >= N.\n*\n*  VT     (input/output) REAL array, dimension (LDVT,M)\n*         On entry VT' contains the right singular vectors of two\n*         submatrices in the two square blocks with corners at (1,1),\n*         (NL+1, NL+1), and (NL+2, NL+2), (M,M).\n*         On exit VT' contains the trailing (N-K) updated right singular\n*         vectors (those which were deflated) in its last N-K columns.\n*         In case SQRE =1, the last row of VT spans the right null\n*         space.\n*\n*  LDVT   (input) INTEGER\n*         The leading dimension of the array VT.  LDVT >= M.\n*\n*  DSIGMA (output) REAL array, dimension (N)\n*         Contains a copy of the diagonal elements (K-1 singular values\n*         and one zero) in the secular equation.\n*\n*  U2     (output) REAL array, dimension (LDU2,N)\n*         Contains a copy of the first K-1 left singular vectors which\n*         will be used by SLASD3 in a matrix multiply (SGEMM) to solve\n*         for the new left singular vectors. U2 is arranged into four\n*         blocks. The first block contains a column with 1 at NL+1 and\n*         zero everywhere else; the second block contains non-zero\n*         entries only at and above NL; the third contains non-zero\n*         entries only below NL+1; and the fourth is dense.\n*\n*  LDU2   (input) INTEGER\n*         The leading dimension of the array U2.  LDU2 >= N.\n*\n*  VT2    (output) REAL array, dimension (LDVT2,N)\n*         VT2' contains a copy of the first K right singular vectors\n*         which will be used by SLASD3 in a matrix multiply (SGEMM) to\n*         solve for the new right singular vectors. VT2 is arranged into\n*         three blocks. The first block contains a row that corresponds\n*         to the special 0 diagonal element in SIGMA; the second block\n*         contains non-zeros only at and before NL +1; the third block\n*         contains non-zeros only at and after  NL +2.\n*\n*  LDVT2  (input) INTEGER\n*         The leading dimension of the array VT2.  LDVT2 >= M.\n*\n*  IDXP   (workspace) INTEGER array, dimension (N)\n*         This will contain the permutation used to place deflated\n*         values of D at the end of the array. On output IDXP(2:K)\n*         points to the nondeflated D-values and IDXP(K+1:N)\n*         points to the deflated singular values.\n*\n*  IDX    (workspace) INTEGER array, dimension (N)\n*         This will contain the permutation used to sort the contents of\n*         D into ascending order.\n*\n*  IDXC   (output) INTEGER array, dimension (N)\n*         This will contain the permutation used to arrange the columns\n*         of the deflated U matrix into three groups:  the first group\n*         contains non-zero entries only at and above NL, the second\n*         contains non-zero entries only below NL+2, and the third is\n*         dense.\n*\n*  IDXQ   (input/output) INTEGER array, dimension (N)\n*         This contains the permutation which separately sorts the two\n*         sub-problems in D into ascending order.  Note that entries in\n*         the first hlaf of this permutation must first be moved one\n*         position backward; and entries in the second half\n*         must first have NL+1 added to their values.\n*\n*  COLTYP (workspace/output) INTEGER array, dimension (N)\n*         As workspace, this will contain a label which will indicate\n*         which of the following types a column in the U2 matrix or a\n*         row in the VT2 matrix is:\n*         1 : non-zero in the upper half only\n*         2 : non-zero in the lower half only\n*         3 : dense\n*         4 : deflated\n*\n*         On exit, it is an array of dimension 4, with COLTYP(I) being\n*         the dimension of the I-th type columns.\n*\n*  INFO   (output) INTEGER\n*          = 0:  successful exit.\n*          < 0:  if INFO = -i, the i-th argument had an illegal value.\n*\n\n*  Further Details\n*  ===============\n*\n*  Based on contributions by\n*     Ming Gu and Huan Ren, Computer Science Division, University of\n*     California at Berkeley, USA\n*\n*  =====================================================================\n*\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  k, z, dsigma, u2, vt2, idxc, coltyp, info, d, u, vt, idxq = NumRu::Lapack.slasd2( nl, nr, sqre, d, alpha, beta, u, vt, idxq, [: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_nl = argv[0];
+  rblapack_nr = argv[1];
+  rblapack_sqre = argv[2];
+  rblapack_d = argv[3];
+  rblapack_alpha = argv[4];
+  rblapack_beta = argv[5];
+  rblapack_u = argv[6];
+  rblapack_vt = argv[7];
+  rblapack_idxq = argv[8];
+  if (argc == 9) {
+  } else if (rblapack_options != Qnil) {
+  } else {
+  }
+
+  nl = NUM2INT(rblapack_nl);
+  sqre = NUM2INT(rblapack_sqre);
+  alpha = (real)NUM2DBL(rblapack_alpha);
+  if (!NA_IsNArray(rblapack_u))
+    rb_raise(rb_eArgError, "u (7th argument) must be NArray");
+  if (NA_RANK(rblapack_u) != 2)
+    rb_raise(rb_eArgError, "rank of u (7th argument) must be %d", 2);
+  ldu = NA_SHAPE0(rblapack_u);
+  n = NA_SHAPE1(rblapack_u);
+  if (NA_TYPE(rblapack_u) != NA_SFLOAT)
+    rblapack_u = na_change_type(rblapack_u, NA_SFLOAT);
+  u = NA_PTR_TYPE(rblapack_u, real*);
+  if (!NA_IsNArray(rblapack_idxq))
+    rb_raise(rb_eArgError, "idxq (9th argument) must be NArray");
+  if (NA_RANK(rblapack_idxq) != 1)
+    rb_raise(rb_eArgError, "rank of idxq (9th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_idxq) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of idxq must be the same as shape 1 of u");
+  if (NA_TYPE(rblapack_idxq) != NA_LINT)
+    rblapack_idxq = na_change_type(rblapack_idxq, NA_LINT);
+  idxq = NA_PTR_TYPE(rblapack_idxq, integer*);
+  nr = NUM2INT(rblapack_nr);
+  beta = (real)NUM2DBL(rblapack_beta);
+  if (!NA_IsNArray(rblapack_d))
+    rb_raise(rb_eArgError, "d (4th argument) must be NArray");
+  if (NA_RANK(rblapack_d) != 1)
+    rb_raise(rb_eArgError, "rank of d (4th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_d) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of d must be the same as shape 1 of u");
+  if (NA_TYPE(rblapack_d) != NA_SFLOAT)
+    rblapack_d = na_change_type(rblapack_d, NA_SFLOAT);
+  d = NA_PTR_TYPE(rblapack_d, real*);
+  ldu2 = n;
+  if (!NA_IsNArray(rblapack_vt))
+    rb_raise(rb_eArgError, "vt (8th argument) must be NArray");
+  if (NA_RANK(rblapack_vt) != 2)
+    rb_raise(rb_eArgError, "rank of vt (8th argument) must be %d", 2);
+  ldvt = NA_SHAPE0(rblapack_vt);
+  m = NA_SHAPE1(rblapack_vt);
+  if (NA_TYPE(rblapack_vt) != NA_SFLOAT)
+    rblapack_vt = na_change_type(rblapack_vt, NA_SFLOAT);
+  vt = NA_PTR_TYPE(rblapack_vt, real*);
+  ldvt2 = m;
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_z = na_make_object(NA_SFLOAT, 1, shape, cNArray);
+  }
+  z = NA_PTR_TYPE(rblapack_z, real*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_dsigma = na_make_object(NA_SFLOAT, 1, shape, cNArray);
+  }
+  dsigma = NA_PTR_TYPE(rblapack_dsigma, real*);
+  {
+    na_shape_t shape[2];
+    shape[0] = ldu2;
+    shape[1] = n;
+    rblapack_u2 = na_make_object(NA_SFLOAT, 2, shape, cNArray);
+  }
+  u2 = NA_PTR_TYPE(rblapack_u2, real*);
+  {
+    na_shape_t shape[2];
+    shape[0] = ldvt2;
+    shape[1] = n;
+    rblapack_vt2 = na_make_object(NA_SFLOAT, 2, shape, cNArray);
+  }
+  vt2 = NA_PTR_TYPE(rblapack_vt2, real*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_idxc = na_make_object(NA_LINT, 1, shape, cNArray);
+  }
+  idxc = NA_PTR_TYPE(rblapack_idxc, integer*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_coltyp = na_make_object(NA_LINT, 1, shape, cNArray);
+  }
+  coltyp = NA_PTR_TYPE(rblapack_coltyp, integer*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_d_out__ = na_make_object(NA_SFLOAT, 1, shape, cNArray);
+  }
+  d_out__ = NA_PTR_TYPE(rblapack_d_out__, real*);
+  MEMCPY(d_out__, d, real, NA_TOTAL(rblapack_d));
+  rblapack_d = rblapack_d_out__;
+  d = d_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = ldu;
+    shape[1] = n;
+    rblapack_u_out__ = na_make_object(NA_SFLOAT, 2, shape, cNArray);
+  }
+  u_out__ = NA_PTR_TYPE(rblapack_u_out__, real*);
+  MEMCPY(u_out__, u, real, NA_TOTAL(rblapack_u));
+  rblapack_u = rblapack_u_out__;
+  u = u_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = ldvt;
+    shape[1] = m;
+    rblapack_vt_out__ = na_make_object(NA_SFLOAT, 2, shape, cNArray);
+  }
+  vt_out__ = NA_PTR_TYPE(rblapack_vt_out__, real*);
+  MEMCPY(vt_out__, vt, real, NA_TOTAL(rblapack_vt));
+  rblapack_vt = rblapack_vt_out__;
+  vt = vt_out__;
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_idxq_out__ = na_make_object(NA_LINT, 1, shape, cNArray);
+  }
+  idxq_out__ = NA_PTR_TYPE(rblapack_idxq_out__, integer*);
+  MEMCPY(idxq_out__, idxq, integer, NA_TOTAL(rblapack_idxq));
+  rblapack_idxq = rblapack_idxq_out__;
+  idxq = idxq_out__;
+  idxp = ALLOC_N(integer, (n));
+  idx = ALLOC_N(integer, (n));
+
+  slasd2_(&nl, &nr, &sqre, &k, d, z, &alpha, &beta, u, &ldu, vt, &ldvt, dsigma, u2, &ldu2, vt2, &ldvt2, idxp, idx, idxc, idxq, coltyp, &info);
+
+  free(idxp);
+  free(idx);
+  rblapack_k = INT2NUM(k);
+  rblapack_info = INT2NUM(info);
+  return rb_ary_new3(12, rblapack_k, rblapack_z, rblapack_dsigma, rblapack_u2, rblapack_vt2, rblapack_idxc, rblapack_coltyp, rblapack_info, rblapack_d, rblapack_u, rblapack_vt, rblapack_idxq);
+}
+
+void
+init_lapack_slasd2(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "slasd2", rblapack_slasd2, -1);
+}

data/ext/slasd3.c

@@ -0,0 +1,212 @@
+#include "rb_lapack.h"
+
+extern VOID slasd3_(integer* nl, integer* nr, integer* sqre, integer* k, real* d, real* q, integer* ldq, real* dsigma, real* u, integer* ldu, real* u2, integer* ldu2, real* vt, integer* ldvt, real* vt2, integer* ldvt2, integer* idxc, integer* ctot, real* z, integer* info);
+
+
+static VALUE
+rblapack_slasd3(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_nl;
+  integer nl; 
+  VALUE rblapack_nr;
+  integer nr; 
+  VALUE rblapack_sqre;
+  integer sqre; 
+  VALUE rblapack_dsigma;
+  real *dsigma; 
+  VALUE rblapack_u2;
+  real *u2; 
+  VALUE rblapack_vt2;
+  real *vt2; 
+  VALUE rblapack_idxc;
+  integer *idxc; 
+  VALUE rblapack_ctot;
+  integer *ctot; 
+  VALUE rblapack_z;
+  real *z; 
+  VALUE rblapack_d;
+  real *d; 
+  VALUE rblapack_u;
+  real *u; 
+  VALUE rblapack_vt;
+  real *vt; 
+  VALUE rblapack_info;
+  integer info; 
+  VALUE rblapack_dsigma_out__;
+  real *dsigma_out__;
+  VALUE rblapack_vt2_out__;
+  real *vt2_out__;
+  VALUE rblapack_z_out__;
+  real *z_out__;
+  real *q;
+
+  integer k;
+  integer ldu2;
+  integer n;
+  integer ldvt2;
+  integer ldu;
+  integer ldvt;
+  integer m;
+  integer ldq;
+
+  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  d, u, vt, info, dsigma, vt2, z = NumRu::Lapack.slasd3( nl, nr, sqre, dsigma, u2, vt2, idxc, ctot, z, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SLASD3( NL, NR, SQRE, K, D, Q, LDQ, DSIGMA, U, LDU, U2, LDU2, VT, LDVT, VT2, LDVT2, IDXC, CTOT, Z, INFO )\n\n*  Purpose\n*  =======\n*\n*  SLASD3 finds all the square roots of the roots of the secular\n*  equation, as defined by the values in D and Z.  It makes the\n*  appropriate calls to SLASD4 and then updates the singular\n*  vectors by matrix multiplication.\n*\n*  This code makes very mild assumptions about floating point\n*  arithmetic. It will work on machines with a guard digit in\n*  add/subtract, or on those binary machines without guard digits\n*  which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2.\n*  It could conceivably fail on hexadecimal or decimal machines\n*  without guard digits, but we know of none.\n*\n*  SLASD3 is called from SLASD1.\n*\n\n*  Arguments\n*  =========\n*\n*  NL     (input) INTEGER\n*         The row dimension of the upper block.  NL >= 1.\n*\n*  NR     (input) INTEGER\n*         The row dimension of the lower block.  NR >= 1.\n*\n*  SQRE   (input) INTEGER\n*         = 0: the lower block is an NR-by-NR square matrix.\n*         = 1: the lower block is an NR-by-(NR+1) rectangular matrix.\n*\n*         The bidiagonal matrix has N = NL + NR + 1 rows and\n*         M = N + SQRE >= N columns.\n*\n*  K      (input) INTEGER\n*         The size of the secular equation, 1 =< K = < N.\n*\n*  D      (output) REAL array, dimension(K)\n*         On exit the square roots of the roots of the secular equation,\n*         in ascending order.\n*\n*  Q      (workspace) REAL array,\n*                     dimension at least (LDQ,K).\n*\n*  LDQ    (input) INTEGER\n*         The leading dimension of the array Q.  LDQ >= K.\n*\n*  DSIGMA (input/output) REAL array, dimension(K)\n*         The first K elements of this array contain the old roots\n*         of the deflated updating problem.  These are the poles\n*         of the secular equation.\n*\n*  U      (output) REAL array, dimension (LDU, N)\n*         The last N - K columns of this matrix contain the deflated\n*         left singular vectors.\n*\n*  LDU    (input) INTEGER\n*         The leading dimension of the array U.  LDU >= N.\n*\n*  U2     (input) REAL array, dimension (LDU2, N)\n*         The first K columns of this matrix contain the non-deflated\n*         left singular vectors for the split problem.\n*\n*  LDU2   (input) INTEGER\n*         The leading dimension of the array U2.  LDU2 >= N.\n*\n*  VT     (output) REAL array, dimension (LDVT, M)\n*         The last M - K columns of VT' contain the deflated\n*         right singular vectors.\n*\n*  LDVT   (input) INTEGER\n*         The leading dimension of the array VT.  LDVT >= N.\n*\n*  VT2    (input/output) REAL array, dimension (LDVT2, N)\n*         The first K columns of VT2' contain the non-deflated\n*         right singular vectors for the split problem.\n*\n*  LDVT2  (input) INTEGER\n*         The leading dimension of the array VT2.  LDVT2 >= N.\n*\n*  IDXC   (input) INTEGER array, dimension (N)\n*         The permutation used to arrange the columns of U (and rows of\n*         VT) into three groups:  the first group contains non-zero\n*         entries only at and above (or before) NL +1; the second\n*         contains non-zero entries only at and below (or after) NL+2;\n*         and the third is dense. The first column of U and the row of\n*         VT are treated separately, however.\n*\n*         The rows of the singular vectors found by SLASD4\n*         must be likewise permuted before the matrix multiplies can\n*         take place.\n*\n*  CTOT   (input) INTEGER array, dimension (4)\n*         A count of the total number of the various types of columns\n*         in U (or rows in VT), as described in IDXC. The fourth column\n*         type is any column which has been deflated.\n*\n*  Z      (input/output) REAL array, dimension (K)\n*         The first K elements of this array contain the components\n*         of the deflation-adjusted updating row vector.\n*\n*  INFO   (output) INTEGER\n*         = 0:  successful exit.\n*         < 0:  if INFO = -i, the i-th argument had an illegal value.\n*         > 0:  if INFO = 1, a singular value did not converge\n*\n\n*  Further Details\n*  ===============\n*\n*  Based on contributions by\n*     Ming Gu and Huan Ren, Computer Science Division, University of\n*     California at Berkeley, USA\n*\n*  =====================================================================\n*\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  d, u, vt, info, dsigma, vt2, z = NumRu::Lapack.slasd3( nl, nr, sqre, dsigma, u2, vt2, idxc, ctot, z, [: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_nl = argv[0];
+  rblapack_nr = argv[1];
+  rblapack_sqre = argv[2];
+  rblapack_dsigma = argv[3];
+  rblapack_u2 = argv[4];
+  rblapack_vt2 = argv[5];
+  rblapack_idxc = argv[6];
+  rblapack_ctot = argv[7];
+  rblapack_z = argv[8];
+  if (argc == 9) {
+  } else if (rblapack_options != Qnil) {
+  } else {
+  }
+
+  nl = NUM2INT(rblapack_nl);
+  sqre = NUM2INT(rblapack_sqre);
+  if (!NA_IsNArray(rblapack_ctot))
+    rb_raise(rb_eArgError, "ctot (8th argument) must be NArray");
+  if (NA_RANK(rblapack_ctot) != 1)
+    rb_raise(rb_eArgError, "rank of ctot (8th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_ctot) != (4))
+    rb_raise(rb_eRuntimeError, "shape 0 of ctot must be %d", 4);
+  if (NA_TYPE(rblapack_ctot) != NA_LINT)
+    rblapack_ctot = na_change_type(rblapack_ctot, NA_LINT);
+  ctot = NA_PTR_TYPE(rblapack_ctot, integer*);
+  nr = NUM2INT(rblapack_nr);
+  if (!NA_IsNArray(rblapack_z))
+    rb_raise(rb_eArgError, "z (9th argument) must be NArray");
+  if (NA_RANK(rblapack_z) != 1)
+    rb_raise(rb_eArgError, "rank of z (9th argument) must be %d", 1);
+  k = NA_SHAPE0(rblapack_z);
+  if (NA_TYPE(rblapack_z) != NA_SFLOAT)
+    rblapack_z = na_change_type(rblapack_z, NA_SFLOAT);
+  z = NA_PTR_TYPE(rblapack_z, real*);
+  n = nl + nr + 1;
+  ldvt = n;
+  ldu = n;
+  if (!NA_IsNArray(rblapack_dsigma))
+    rb_raise(rb_eArgError, "dsigma (4th argument) must be NArray");
+  if (NA_RANK(rblapack_dsigma) != 1)
+    rb_raise(rb_eArgError, "rank of dsigma (4th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_dsigma) != k)
+    rb_raise(rb_eRuntimeError, "shape 0 of dsigma must be the same as shape 0 of z");
+  if (NA_TYPE(rblapack_dsigma) != NA_SFLOAT)
+    rblapack_dsigma = na_change_type(rblapack_dsigma, NA_SFLOAT);
+  dsigma = NA_PTR_TYPE(rblapack_dsigma, real*);
+  if (!NA_IsNArray(rblapack_idxc))
+    rb_raise(rb_eArgError, "idxc (7th argument) must be NArray");
+  if (NA_RANK(rblapack_idxc) != 1)
+    rb_raise(rb_eArgError, "rank of idxc (7th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_idxc) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of idxc must be nl + nr + 1");
+  if (NA_TYPE(rblapack_idxc) != NA_LINT)
+    rblapack_idxc = na_change_type(rblapack_idxc, NA_LINT);
+  idxc = NA_PTR_TYPE(rblapack_idxc, integer*);
+  ldq = k;
+  ldvt2 = n;
+  if (!NA_IsNArray(rblapack_vt2))
+    rb_raise(rb_eArgError, "vt2 (6th argument) must be NArray");
+  if (NA_RANK(rblapack_vt2) != 2)
+    rb_raise(rb_eArgError, "rank of vt2 (6th argument) must be %d", 2);
+  if (NA_SHAPE0(rblapack_vt2) != ldvt2)
+    rb_raise(rb_eRuntimeError, "shape 0 of vt2 must be n");
+  if (NA_SHAPE1(rblapack_vt2) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of vt2 must be nl + nr + 1");
+  if (NA_TYPE(rblapack_vt2) != NA_SFLOAT)
+    rblapack_vt2 = na_change_type(rblapack_vt2, NA_SFLOAT);
+  vt2 = NA_PTR_TYPE(rblapack_vt2, real*);
+  ldu2 = n;
+  if (!NA_IsNArray(rblapack_u2))
+    rb_raise(rb_eArgError, "u2 (5th argument) must be NArray");
+  if (NA_RANK(rblapack_u2) != 2)
+    rb_raise(rb_eArgError, "rank of u2 (5th argument) must be %d", 2);
+  if (NA_SHAPE0(rblapack_u2) != ldu2)
+    rb_raise(rb_eRuntimeError, "shape 0 of u2 must be n");
+  if (NA_SHAPE1(rblapack_u2) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of u2 must be nl + nr + 1");
+  if (NA_TYPE(rblapack_u2) != NA_SFLOAT)
+    rblapack_u2 = na_change_type(rblapack_u2, NA_SFLOAT);
+  u2 = NA_PTR_TYPE(rblapack_u2, real*);
+  m = n+sqre;
+  {
+    na_shape_t shape[1];
+    shape[0] = k;
+    rblapack_d = na_make_object(NA_SFLOAT, 1, shape, cNArray);
+  }
+  d = NA_PTR_TYPE(rblapack_d, real*);
+  {
+    na_shape_t shape[2];
+    shape[0] = ldu;
+    shape[1] = n;
+    rblapack_u = na_make_object(NA_SFLOAT, 2, shape, cNArray);
+  }
+  u = NA_PTR_TYPE(rblapack_u, real*);
+  {
+    na_shape_t shape[2];
+    shape[0] = ldvt;
+    shape[1] = m;
+    rblapack_vt = na_make_object(NA_SFLOAT, 2, shape, cNArray);
+  }
+  vt = NA_PTR_TYPE(rblapack_vt, real*);
+  {
+    na_shape_t shape[1];
+    shape[0] = k;
+    rblapack_dsigma_out__ = na_make_object(NA_SFLOAT, 1, shape, cNArray);
+  }
+  dsigma_out__ = NA_PTR_TYPE(rblapack_dsigma_out__, real*);
+  MEMCPY(dsigma_out__, dsigma, real, NA_TOTAL(rblapack_dsigma));
+  rblapack_dsigma = rblapack_dsigma_out__;
+  dsigma = dsigma_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = ldvt2;
+    shape[1] = n;
+    rblapack_vt2_out__ = na_make_object(NA_SFLOAT, 2, shape, cNArray);
+  }
+  vt2_out__ = NA_PTR_TYPE(rblapack_vt2_out__, real*);
+  MEMCPY(vt2_out__, vt2, real, NA_TOTAL(rblapack_vt2));
+  rblapack_vt2 = rblapack_vt2_out__;
+  vt2 = vt2_out__;
+  {
+    na_shape_t shape[1];
+    shape[0] = k;
+    rblapack_z_out__ = na_make_object(NA_SFLOAT, 1, shape, cNArray);
+  }
+  z_out__ = NA_PTR_TYPE(rblapack_z_out__, real*);
+  MEMCPY(z_out__, z, real, NA_TOTAL(rblapack_z));
+  rblapack_z = rblapack_z_out__;
+  z = z_out__;
+  q = ALLOC_N(real, (ldq)*(k));
+
+  slasd3_(&nl, &nr, &sqre, &k, d, q, &ldq, dsigma, u, &ldu, u2, &ldu2, vt, &ldvt, vt2, &ldvt2, idxc, ctot, z, &info);
+
+  free(q);
+  rblapack_info = INT2NUM(info);
+  return rb_ary_new3(7, rblapack_d, rblapack_u, rblapack_vt, rblapack_info, rblapack_dsigma, rblapack_vt2, rblapack_z);
+}
+
+void
+init_lapack_slasd3(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "slasd3", rblapack_slasd3, -1);
+}