ruby-lapack 1.6 → 1.7

data/ext/sgelsy.c

@@ -1,163 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID sgelsy_(integer* m, integer* n, integer* nrhs, real* a, integer* lda, real* b, integer* ldb, integer* jpvt, real* rcond, integer* rank, real* work, integer* lwork, integer* info);
-
-
-static VALUE
-rblapack_sgelsy(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_a;
-  real *a; 
-  VALUE rblapack_b;
-  real *b; 
-  VALUE rblapack_jpvt;
-  integer *jpvt; 
-  VALUE rblapack_rcond;
-  real rcond; 
-  VALUE rblapack_lwork;
-  integer lwork; 
-  VALUE rblapack_rank;
-  integer rank; 
-  VALUE rblapack_work;
-  real *work; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack_a_out__;
-  real *a_out__;
-  VALUE rblapack_b_out__;
-  real *b_out__;
-  VALUE rblapack_jpvt_out__;
-  integer *jpvt_out__;
-
-  integer lda;
-  integer n;
-  integer m;
-  integer nrhs;
-  integer ldb;
-
-  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  rank, work, info, a, b, jpvt = NumRu::Lapack.sgelsy( a, b, jpvt, rcond, [:lwork => lwork, :usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SGELSY( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK, WORK, LWORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  SGELSY computes the minimum-norm solution to a real linear least\n*  squares problem:\n*      minimize || A * X - B ||\n*  using a complete orthogonal factorization of A.  A is an M-by-N\n*  matrix which may be rank-deficient.\n*\n*  Several right hand side vectors b and solution vectors x can be\n*  handled in a single call; they are stored as the columns of the\n*  M-by-NRHS right hand side matrix B and the N-by-NRHS solution\n*  matrix X.\n*\n*  The routine first computes a QR factorization with column pivoting:\n*      A * P = Q * [ R11 R12 ]\n*                  [  0  R22 ]\n*  with R11 defined as the largest leading submatrix whose estimated\n*  condition number is less than 1/RCOND.  The order of R11, RANK,\n*  is the effective rank of A.\n*\n*  Then, R22 is considered to be negligible, and R12 is annihilated\n*  by orthogonal transformations from the right, arriving at the\n*  complete orthogonal factorization:\n*     A * P = Q * [ T11 0 ] * Z\n*                 [  0  0 ]\n*  The minimum-norm solution is then\n*     X = P * Z' [ inv(T11)*Q1'*B ]\n*                [        0       ]\n*  where Q1 consists of the first RANK columns of Q.\n*\n*  This routine is basically identical to the original xGELSX except\n*  three differences:\n*    o The call to the subroutine xGEQPF has been substituted by the\n*      the call to the subroutine xGEQP3. This subroutine is a Blas-3\n*      version of the QR factorization with column pivoting.\n*    o Matrix B (the right hand side) is updated with Blas-3.\n*    o The permutation of matrix B (the right hand side) is faster and\n*      more simple.\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*  NRHS    (input) INTEGER\n*          The number of right hand sides, i.e., the number of\n*          columns of matrices B and X. NRHS >= 0.\n*\n*  A       (input/output) REAL array, dimension (LDA,N)\n*          On entry, the M-by-N matrix A.\n*          On exit, A has been overwritten by details of its\n*          complete orthogonal factorization.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A.  LDA >= max(1,M).\n*\n*  B       (input/output) REAL array, dimension (LDB,NRHS)\n*          On entry, the M-by-NRHS right hand side matrix B.\n*          On exit, the N-by-NRHS solution matrix X.\n*\n*  LDB     (input) INTEGER\n*          The leading dimension of the array B. LDB >= max(1,M,N).\n*\n*  JPVT    (input/output) INTEGER array, dimension (N)\n*          On entry, if JPVT(i) .ne. 0, the i-th column of A is permuted\n*          to the front of AP, otherwise column i is a free column.\n*          On exit, if JPVT(i) = k, then the i-th column of AP\n*          was the k-th column of A.\n*\n*  RCOND   (input) REAL\n*          RCOND is used to determine the effective rank of A, which\n*          is defined as the order of the largest leading triangular\n*          submatrix R11 in the QR factorization with pivoting of A,\n*          whose estimated condition number < 1/RCOND.\n*\n*  RANK    (output) INTEGER\n*          The effective rank of A, i.e., the order of the submatrix\n*          R11.  This is the same as the order of the submatrix T11\n*          in the complete orthogonal factorization of A.\n*\n*  WORK    (workspace/output) REAL array, dimension (MAX(1,LWORK))\n*          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.\n*\n*  LWORK   (input) INTEGER\n*          The dimension of the array WORK.\n*          The unblocked strategy requires that:\n*             LWORK >= MAX( MN+3*N+1, 2*MN+NRHS ),\n*          where MN = min( M, N ).\n*          The block algorithm requires that:\n*             LWORK >= MAX( MN+2*N+NB*(N+1), 2*MN+NB*NRHS ),\n*          where NB is an upper bound on the blocksize returned\n*          by ILAENV for the routines SGEQP3, STZRZF, STZRQF, SORMQR,\n*          and SORMRZ.\n*\n*          If LWORK = -1, then a workspace query is assumed; the routine\n*          only calculates the optimal size of the WORK array, returns\n*          this value as the first entry of the WORK array, and no error\n*          message related to LWORK is issued by XERBLA.\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*    A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA\n*    E. Quintana-Orti, Depto. de Informatica, Universidad Jaime I, Spain\n*    G. Quintana-Orti, Depto. de Informatica, Universidad Jaime I, Spain\n*\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  rank, work, info, a, b, jpvt = NumRu::Lapack.sgelsy( a, b, jpvt, rcond, [:lwork => lwork, :usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 4 && argc != 5)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 4)", argc);
-  rblapack_a = argv[0];
-  rblapack_b = argv[1];
-  rblapack_jpvt = argv[2];
-  rblapack_rcond = argv[3];
-  if (argc == 5) {
-    rblapack_lwork = argv[4];
-  } else if (rblapack_options != Qnil) {
-    rblapack_lwork = rb_hash_aref(rblapack_options, ID2SYM(rb_intern("lwork")));
-  } else {
-    rblapack_lwork = Qnil;
-  }
-
-  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*);
-  if (!NA_IsNArray(rblapack_jpvt))
-    rb_raise(rb_eArgError, "jpvt (3th argument) must be NArray");
-  if (NA_RANK(rblapack_jpvt) != 1)
-    rb_raise(rb_eArgError, "rank of jpvt (3th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_jpvt) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of jpvt must be the same as shape 1 of a");
-  if (NA_TYPE(rblapack_jpvt) != NA_LINT)
-    rblapack_jpvt = na_change_type(rblapack_jpvt, NA_LINT);
-  jpvt = NA_PTR_TYPE(rblapack_jpvt, integer*);
-  m = lda;
-  if (!NA_IsNArray(rblapack_b))
-    rb_raise(rb_eArgError, "b (2th argument) must be NArray");
-  if (NA_RANK(rblapack_b) != 2)
-    rb_raise(rb_eArgError, "rank of b (2th argument) must be %d", 2);
-  if (NA_SHAPE0(rblapack_b) != m)
-    rb_raise(rb_eRuntimeError, "shape 0 of b must be lda");
-  nrhs = NA_SHAPE1(rblapack_b);
-  if (NA_TYPE(rblapack_b) != NA_SFLOAT)
-    rblapack_b = na_change_type(rblapack_b, NA_SFLOAT);
-  b = NA_PTR_TYPE(rblapack_b, real*);
-  if (rblapack_lwork == Qnil)
-    lwork = MAX(MIN(m,n)+3*n+1, 2*MIN(m,n)+nrhs);
-  else {
-    lwork = NUM2INT(rblapack_lwork);
-  }
-  rcond = (real)NUM2DBL(rblapack_rcond);
-  ldb = MAX(m,n);
-  {
-    int shape[1];
-    shape[0] = MAX(1,lwork);
-    rblapack_work = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  work = NA_PTR_TYPE(rblapack_work, real*);
-  {
-    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__;
-  {
-    int shape[2];
-    shape[0] = MAX(m, n);
-    shape[1] = nrhs;
-    rblapack_b_out__ = na_make_object(NA_SFLOAT, 2, shape, cNArray);
-  }
-  b_out__ = NA_PTR_TYPE(rblapack_b_out__, real*);
-  {
-    VALUE __shape__[3];
-    __shape__[0] = m < n ? rb_range_new(rblapack_ZERO, INT2NUM(m), Qtrue) : Qtrue;
-    __shape__[1] = Qtrue;
-    __shape__[2] = rblapack_b;
-    na_aset(3, __shape__, rblapack_b_out__);
-  }
-  rblapack_b = rblapack_b_out__;
-  b = b_out__;
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_jpvt_out__ = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  jpvt_out__ = NA_PTR_TYPE(rblapack_jpvt_out__, integer*);
-  MEMCPY(jpvt_out__, jpvt, integer, NA_TOTAL(rblapack_jpvt));
-  rblapack_jpvt = rblapack_jpvt_out__;
-  jpvt = jpvt_out__;
-
-  sgelsy_(&m, &n, &nrhs, a, &lda, b, &ldb, jpvt, &rcond, &rank, work, &lwork, &info);
-
-  rblapack_rank = INT2NUM(rank);
-  rblapack_info = INT2NUM(info);
-  {
-    VALUE __shape__[2];
-    __shape__[0] = m < n ? Qtrue : rb_range_new(rblapack_ZERO, INT2NUM(n), Qtrue);
-    __shape__[1] = Qtrue;
-    rblapack_b = na_aref(2, __shape__, rblapack_b);
-  }
-  return rb_ary_new3(6, rblapack_rank, rblapack_work, rblapack_info, rblapack_a, rblapack_b, rblapack_jpvt);
-}
-
-void
-init_lapack_sgelsy(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "sgelsy", rblapack_sgelsy, -1);
-}

data/ext/sgeql2.c

@@ -1,88 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID sgeql2_(integer* m, integer* n, real* a, integer* lda, real* tau, real* work, integer* info);
-
-
-static VALUE
-rblapack_sgeql2(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_a;
-  real *a; 
-  VALUE rblapack_tau;
-  real *tau; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack_a_out__;
-  real *a_out__;
-  real *work;
-
-  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  tau, info, a = NumRu::Lapack.sgeql2( m, a, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SGEQL2( M, N, A, LDA, TAU, WORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  SGEQL2 computes a QL factorization of a real m by n matrix A:\n*  A = Q * L.\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) REAL array, dimension (LDA,N)\n*          On entry, the m by n matrix A.\n*          On exit, if m >= n, the lower triangle of the subarray\n*          A(m-n+1:m,1:n) contains the n by n lower triangular matrix L;\n*          if m <= n, the elements on and below the (n-m)-th\n*          superdiagonal contain the m by n lower trapezoidal matrix L;\n*          the remaining elements, with the array TAU, represent the\n*          orthogonal matrix Q as a product of elementary reflectors\n*          (see Further Details).\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A.  LDA >= max(1,M).\n*\n*  TAU     (output) REAL array, dimension (min(M,N))\n*          The scalar factors of the elementary reflectors (see Further\n*          Details).\n*\n*  WORK    (workspace) REAL array, dimension (N)\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*  The matrix Q is represented as a product of elementary reflectors\n*\n*     Q = H(k) . . . H(2) H(1), where k = min(m,n).\n*\n*  Each H(i) has the form\n*\n*     H(i) = I - tau * v * v'\n*\n*  where tau is a real scalar, and v is a real vector with\n*  v(m-k+i+1:m) = 0 and v(m-k+i) = 1; v(1:m-k+i-1) is stored on exit in\n*  A(1:m-k+i-1,n-k+i), and tau in TAU(i).\n*\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  tau, info, a = NumRu::Lapack.sgeql2( m, a, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 2 && argc != 2)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 2)", argc);
-  rblapack_m = argv[0];
-  rblapack_a = argv[1];
-  if (argc == 2) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  m = NUM2INT(rblapack_m);
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (2th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (2th argument) must be %d", 2);
-  lda = NA_SHAPE0(rblapack_a);
-  n = NA_SHAPE1(rblapack_a);
-  if (NA_TYPE(rblapack_a) != NA_SFLOAT)
-    rblapack_a = na_change_type(rblapack_a, NA_SFLOAT);
-  a = NA_PTR_TYPE(rblapack_a, real*);
-  {
-    int shape[1];
-    shape[0] = MIN(m,n);
-    rblapack_tau = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  tau = NA_PTR_TYPE(rblapack_tau, real*);
-  {
-    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__;
-  work = ALLOC_N(real, (n));
-
-  sgeql2_(&m, &n, a, &lda, tau, work, &info);
-
-  free(work);
-  rblapack_info = INT2NUM(info);
-  return rb_ary_new3(3, rblapack_tau, rblapack_info, rblapack_a);
-}
-
-void
-init_lapack_sgeql2(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "sgeql2", rblapack_sgeql2, -1);
-}

data/ext/sgeqlf.c

@@ -1,103 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID sgeqlf_(integer* m, integer* n, real* a, integer* lda, real* tau, real* work, integer* lwork, integer* info);
-
-
-static VALUE
-rblapack_sgeqlf(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_a;
-  real *a; 
-  VALUE rblapack_lwork;
-  integer lwork; 
-  VALUE rblapack_tau;
-  real *tau; 
-  VALUE rblapack_work;
-  real *work; 
-  VALUE rblapack_info;
-  integer info; 
-  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  tau, work, info, a = NumRu::Lapack.sgeqlf( m, a, [:lwork => lwork, :usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SGEQLF( M, N, A, LDA, TAU, WORK, LWORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  SGEQLF computes a QL factorization of a real M-by-N matrix A:\n*  A = Q * L.\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) REAL array, dimension (LDA,N)\n*          On entry, the M-by-N matrix A.\n*          On exit,\n*          if m >= n, the lower triangle of the subarray\n*          A(m-n+1:m,1:n) contains the N-by-N lower triangular matrix L;\n*          if m <= n, the elements on and below the (n-m)-th\n*          superdiagonal contain the M-by-N lower trapezoidal matrix L;\n*          the remaining elements, with the array TAU, represent the\n*          orthogonal matrix Q as a product of elementary reflectors\n*          (see Further Details).\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A.  LDA >= max(1,M).\n*\n*  TAU     (output) REAL array, dimension (min(M,N))\n*          The scalar factors of the elementary reflectors (see Further\n*          Details).\n*\n*  WORK    (workspace/output) REAL array, dimension (MAX(1,LWORK))\n*          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.\n*\n*  LWORK   (input) INTEGER\n*          The dimension of the array WORK.  LWORK >= max(1,N).\n*          For optimum performance LWORK >= N*NB, where NB is the\n*          optimal blocksize.\n*\n*          If LWORK = -1, then a workspace query is assumed; the routine\n*          only calculates the optimal size of the WORK array, returns\n*          this value as the first entry of the WORK array, and no error\n*          message related to LWORK is issued by XERBLA.\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*  The matrix Q is represented as a product of elementary reflectors\n*\n*     Q = H(k) . . . H(2) H(1), where k = min(m,n).\n*\n*  Each H(i) has the form\n*\n*     H(i) = I - tau * v * v'\n*\n*  where tau is a real scalar, and v is a real vector with\n*  v(m-k+i+1:m) = 0 and v(m-k+i) = 1; v(1:m-k+i-1) is stored on exit in\n*  A(1:m-k+i-1,n-k+i), and tau in TAU(i).\n*\n*  =====================================================================\n*\n*     .. Local Scalars ..\n      LOGICAL            LQUERY\n      INTEGER            I, IB, IINFO, IWS, K, KI, KK, LDWORK, LWKOPT,\n     $                   MU, NB, NBMIN, NU, NX\n*     ..\n*     .. External Subroutines ..\n      EXTERNAL           SGEQL2, SLARFB, SLARFT, XERBLA\n*     ..\n*     .. Intrinsic Functions ..\n      INTRINSIC          MAX, MIN\n*     ..\n*     .. External Functions ..\n      INTEGER            ILAENV\n      EXTERNAL           ILAENV\n*     ..\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  tau, work, info, a = NumRu::Lapack.sgeqlf( m, a, [:lwork => lwork, :usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 2 && argc != 3)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 2)", argc);
-  rblapack_m = argv[0];
-  rblapack_a = argv[1];
-  if (argc == 3) {
-    rblapack_lwork = argv[2];
-  } else if (rblapack_options != Qnil) {
-    rblapack_lwork = rb_hash_aref(rblapack_options, ID2SYM(rb_intern("lwork")));
-  } else {
-    rblapack_lwork = Qnil;
-  }
-
-  m = NUM2INT(rblapack_m);
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (2th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (2th argument) must be %d", 2);
-  lda = NA_SHAPE0(rblapack_a);
-  n = NA_SHAPE1(rblapack_a);
-  if (NA_TYPE(rblapack_a) != NA_SFLOAT)
-    rblapack_a = na_change_type(rblapack_a, NA_SFLOAT);
-  a = NA_PTR_TYPE(rblapack_a, real*);
-  if (rblapack_lwork == Qnil)
-    lwork = n;
-  else {
-    lwork = NUM2INT(rblapack_lwork);
-  }
-  {
-    int shape[1];
-    shape[0] = MIN(m,n);
-    rblapack_tau = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  tau = NA_PTR_TYPE(rblapack_tau, real*);
-  {
-    int shape[1];
-    shape[0] = MAX(1,lwork);
-    rblapack_work = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  work = NA_PTR_TYPE(rblapack_work, real*);
-  {
-    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__;
-
-  sgeqlf_(&m, &n, a, &lda, tau, work, &lwork, &info);
-
-  rblapack_info = INT2NUM(info);
-  return rb_ary_new3(4, rblapack_tau, rblapack_work, rblapack_info, rblapack_a);
-}
-
-void
-init_lapack_sgeqlf(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "sgeqlf", rblapack_sgeqlf, -1);
-}

data/ext/sgeqp3.c

@@ -1,126 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID sgeqp3_(integer* m, integer* n, real* a, integer* lda, integer* jpvt, real* tau, real* work, integer* lwork, integer* info);
-
-
-static VALUE
-rblapack_sgeqp3(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_a;
-  real *a; 
-  VALUE rblapack_jpvt;
-  integer *jpvt; 
-  VALUE rblapack_lwork;
-  integer lwork; 
-  VALUE rblapack_tau;
-  real *tau; 
-  VALUE rblapack_work;
-  real *work; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack_a_out__;
-  real *a_out__;
-  VALUE rblapack_jpvt_out__;
-  integer *jpvt_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  tau, work, info, a, jpvt = NumRu::Lapack.sgeqp3( m, a, jpvt, [:lwork => lwork, :usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE SGEQP3( M, N, A, LDA, JPVT, TAU, WORK, LWORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  SGEQP3 computes a QR factorization with column pivoting of a\n*  matrix A:  A*P = Q*R  using Level 3 BLAS.\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) REAL array, dimension (LDA,N)\n*          On entry, the M-by-N matrix A.\n*          On exit, the upper triangle of the array contains the\n*          min(M,N)-by-N upper trapezoidal matrix R; the elements below\n*          the diagonal, together with the array TAU, represent the\n*          orthogonal matrix Q as a product of min(M,N) elementary\n*          reflectors.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A. LDA >= max(1,M).\n*\n*  JPVT    (input/output) INTEGER array, dimension (N)\n*          On entry, if JPVT(J).ne.0, the J-th column of A is permuted\n*          to the front of A*P (a leading column); if JPVT(J)=0,\n*          the J-th column of A is a free column.\n*          On exit, if JPVT(J)=K, then the J-th column of A*P was the\n*          the K-th column of A.\n*\n*  TAU     (output) REAL array, dimension (min(M,N))\n*          The scalar factors of the elementary reflectors.\n*\n*  WORK    (workspace/output) REAL array, dimension (MAX(1,LWORK))\n*          On exit, if INFO=0, WORK(1) returns the optimal LWORK.\n*\n*  LWORK   (input) INTEGER\n*          The dimension of the array WORK. LWORK >= 3*N+1.\n*          For optimal performance LWORK >= 2*N+( N+1 )*NB, where NB\n*          is the optimal blocksize.\n*\n*          If LWORK = -1, then a workspace query is assumed; the routine\n*          only calculates the optimal size of the WORK array, returns\n*          this value as the first entry of the WORK array, and no error\n*          message related to LWORK is issued by XERBLA.\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*  The matrix Q is represented as a product of elementary reflectors\n*\n*     Q = H(1) H(2) . . . H(k), where k = min(m,n).\n*\n*  Each H(i) has the form\n*\n*     H(i) = I - tau * v * v'\n*\n*  where tau is a real/complex scalar, and v is a real/complex vector\n*  with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in\n*  A(i+1:m,i), and tau in TAU(i).\n*\n*  Based on contributions by\n*    G. Quintana-Orti, Depto. de Informatica, Universidad Jaime I, Spain\n*    X. Sun, Computer Science Dept., Duke University, USA\n*\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  tau, work, info, a, jpvt = NumRu::Lapack.sgeqp3( m, a, jpvt, [:lwork => lwork, :usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 3 && argc != 4)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 3)", argc);
-  rblapack_m = argv[0];
-  rblapack_a = argv[1];
-  rblapack_jpvt = argv[2];
-  if (argc == 4) {
-    rblapack_lwork = argv[3];
-  } else if (rblapack_options != Qnil) {
-    rblapack_lwork = rb_hash_aref(rblapack_options, ID2SYM(rb_intern("lwork")));
-  } else {
-    rblapack_lwork = Qnil;
-  }
-
-  m = NUM2INT(rblapack_m);
-  if (!NA_IsNArray(rblapack_jpvt))
-    rb_raise(rb_eArgError, "jpvt (3th argument) must be NArray");
-  if (NA_RANK(rblapack_jpvt) != 1)
-    rb_raise(rb_eArgError, "rank of jpvt (3th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_jpvt);
-  if (NA_TYPE(rblapack_jpvt) != NA_LINT)
-    rblapack_jpvt = na_change_type(rblapack_jpvt, NA_LINT);
-  jpvt = NA_PTR_TYPE(rblapack_jpvt, integer*);
-  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 0 of jpvt");
-  if (NA_TYPE(rblapack_a) != NA_SFLOAT)
-    rblapack_a = na_change_type(rblapack_a, NA_SFLOAT);
-  a = NA_PTR_TYPE(rblapack_a, real*);
-  if (rblapack_lwork == Qnil)
-    lwork = 3*n+1;
-  else {
-    lwork = NUM2INT(rblapack_lwork);
-  }
-  {
-    int shape[1];
-    shape[0] = MIN(m,n);
-    rblapack_tau = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  tau = NA_PTR_TYPE(rblapack_tau, real*);
-  {
-    int shape[1];
-    shape[0] = MAX(1,lwork);
-    rblapack_work = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  work = NA_PTR_TYPE(rblapack_work, real*);
-  {
-    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__;
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_jpvt_out__ = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  jpvt_out__ = NA_PTR_TYPE(rblapack_jpvt_out__, integer*);
-  MEMCPY(jpvt_out__, jpvt, integer, NA_TOTAL(rblapack_jpvt));
-  rblapack_jpvt = rblapack_jpvt_out__;
-  jpvt = jpvt_out__;
-
-  sgeqp3_(&m, &n, a, &lda, jpvt, tau, work, &lwork, &info);
-
-  rblapack_info = INT2NUM(info);
-  return rb_ary_new3(5, rblapack_tau, rblapack_work, rblapack_info, rblapack_a, rblapack_jpvt);
-}
-
-void
-init_lapack_sgeqp3(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "sgeqp3", rblapack_sgeqp3, -1);
-}