ruby-lapack 1.7 → 1.7.1

data/ext/zggevx.c

@@ -0,0 +1,226 @@
+#include "rb_lapack.h"
+
+extern VOID zggevx_(char* balanc, char* jobvl, char* jobvr, char* sense, integer* n, doublecomplex* a, integer* lda, doublecomplex* b, integer* ldb, doublecomplex* alpha, doublecomplex* beta, doublecomplex* vl, integer* ldvl, doublecomplex* vr, integer* ldvr, integer* ilo, integer* ihi, doublereal* lscale, doublereal* rscale, doublereal* abnrm, doublereal* bbnrm, doublereal* rconde, doublereal* rcondv, doublecomplex* work, integer* lwork, doublereal* rwork, integer* iwork, logical* bwork, integer* info);
+
+
+static VALUE
+rblapack_zggevx(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_balanc;
+  char balanc; 
+  VALUE rblapack_jobvl;
+  char jobvl; 
+  VALUE rblapack_jobvr;
+  char jobvr; 
+  VALUE rblapack_sense;
+  char sense; 
+  VALUE rblapack_a;
+  doublecomplex *a; 
+  VALUE rblapack_b;
+  doublecomplex *b; 
+  VALUE rblapack_lwork;
+  integer lwork; 
+  VALUE rblapack_alpha;
+  doublecomplex *alpha; 
+  VALUE rblapack_beta;
+  doublecomplex *beta; 
+  VALUE rblapack_vl;
+  doublecomplex *vl; 
+  VALUE rblapack_vr;
+  doublecomplex *vr; 
+  VALUE rblapack_ilo;
+  integer ilo; 
+  VALUE rblapack_ihi;
+  integer ihi; 
+  VALUE rblapack_lscale;
+  doublereal *lscale; 
+  VALUE rblapack_rscale;
+  doublereal *rscale; 
+  VALUE rblapack_abnrm;
+  doublereal abnrm; 
+  VALUE rblapack_bbnrm;
+  doublereal bbnrm; 
+  VALUE rblapack_rconde;
+  doublereal *rconde; 
+  VALUE rblapack_rcondv;
+  doublereal *rcondv; 
+  VALUE rblapack_work;
+  doublecomplex *work; 
+  VALUE rblapack_info;
+  integer info; 
+  VALUE rblapack_a_out__;
+  doublecomplex *a_out__;
+  VALUE rblapack_b_out__;
+  doublecomplex *b_out__;
+  doublereal *rwork;
+  integer *iwork;
+  logical *bwork;
+
+  integer lda;
+  integer n;
+  integer ldb;
+  integer ldvl;
+  integer ldvr;
+  integer lrwork;
+
+  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  alpha, beta, vl, vr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, info, a, b = NumRu::Lapack.zggevx( balanc, jobvl, jobvr, sense, a, b, [:lwork => lwork, :usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE ZGGEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, B, LDB, ALPHA, BETA, VL, LDVL, VR, LDVR, ILO, IHI, LSCALE, RSCALE, ABNRM, BBNRM, RCONDE, RCONDV, WORK, LWORK, RWORK, IWORK, BWORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  ZGGEVX computes for a pair of N-by-N complex nonsymmetric matrices\n*  (A,B) the generalized eigenvalues, and optionally, the left and/or\n*  right generalized eigenvectors.\n*\n*  Optionally, it also computes a balancing transformation to improve\n*  the conditioning of the eigenvalues and eigenvectors (ILO, IHI,\n*  LSCALE, RSCALE, ABNRM, and BBNRM), reciprocal condition numbers for\n*  the eigenvalues (RCONDE), and reciprocal condition numbers for the\n*  right eigenvectors (RCONDV).\n*\n*  A generalized eigenvalue for a pair of matrices (A,B) is a scalar\n*  lambda or a ratio alpha/beta = lambda, such that A - lambda*B is\n*  singular. It is usually represented as the pair (alpha,beta), as\n*  there is a reasonable interpretation for beta=0, and even for both\n*  being zero.\n*\n*  The right eigenvector v(j) corresponding to the eigenvalue lambda(j)\n*  of (A,B) satisfies\n*                   A * v(j) = lambda(j) * B * v(j) .\n*  The left eigenvector u(j) corresponding to the eigenvalue lambda(j)\n*  of (A,B) satisfies\n*                   u(j)**H * A  = lambda(j) * u(j)**H * B.\n*  where u(j)**H is the conjugate-transpose of u(j).\n*\n*\n\n*  Arguments\n*  =========\n*\n*  BALANC  (input) CHARACTER*1\n*          Specifies the balance option to be performed:\n*          = 'N':  do not diagonally scale or permute;\n*          = 'P':  permute only;\n*          = 'S':  scale only;\n*          = 'B':  both permute and scale.\n*          Computed reciprocal condition numbers will be for the\n*          matrices after permuting and/or balancing. Permuting does\n*          not change condition numbers (in exact arithmetic), but\n*          balancing does.\n*\n*  JOBVL   (input) CHARACTER*1\n*          = 'N':  do not compute the left generalized eigenvectors;\n*          = 'V':  compute the left generalized eigenvectors.\n*\n*  JOBVR   (input) CHARACTER*1\n*          = 'N':  do not compute the right generalized eigenvectors;\n*          = 'V':  compute the right generalized eigenvectors.\n*\n*  SENSE   (input) CHARACTER*1\n*          Determines which reciprocal condition numbers are computed.\n*          = 'N': none are computed;\n*          = 'E': computed for eigenvalues only;\n*          = 'V': computed for eigenvectors only;\n*          = 'B': computed for eigenvalues and eigenvectors.\n*\n*  N       (input) INTEGER\n*          The order of the matrices A, B, VL, and VR.  N >= 0.\n*\n*  A       (input/output) COMPLEX*16 array, dimension (LDA, N)\n*          On entry, the matrix A in the pair (A,B).\n*          On exit, A has been overwritten. If JOBVL='V' or JOBVR='V'\n*          or both, then A contains the first part of the complex Schur\n*          form of the \"balanced\" versions of the input A and B.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of A.  LDA >= max(1,N).\n*\n*  B       (input/output) COMPLEX*16 array, dimension (LDB, N)\n*          On entry, the matrix B in the pair (A,B).\n*          On exit, B has been overwritten. If JOBVL='V' or JOBVR='V'\n*          or both, then B contains the second part of the complex\n*          Schur form of the \"balanced\" versions of the input A and B.\n*\n*  LDB     (input) INTEGER\n*          The leading dimension of B.  LDB >= max(1,N).\n*\n*  ALPHA   (output) COMPLEX*16 array, dimension (N)\n*  BETA    (output) COMPLEX*16 array, dimension (N)\n*          On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the generalized\n*          eigenvalues.\n*\n*          Note: the quotient ALPHA(j)/BETA(j) ) may easily over- or\n*          underflow, and BETA(j) may even be zero.  Thus, the user\n*          should avoid naively computing the ratio ALPHA/BETA.\n*          However, ALPHA will be always less than and usually\n*          comparable with norm(A) in magnitude, and BETA always less\n*          than and usually comparable with norm(B).\n*\n*  VL      (output) COMPLEX*16 array, dimension (LDVL,N)\n*          If JOBVL = 'V', the left generalized eigenvectors u(j) are\n*          stored one after another in the columns of VL, in the same\n*          order as their eigenvalues.\n*          Each eigenvector will be scaled so the largest component\n*          will have abs(real part) + abs(imag. part) = 1.\n*          Not referenced if JOBVL = 'N'.\n*\n*  LDVL    (input) INTEGER\n*          The leading dimension of the matrix VL. LDVL >= 1, and\n*          if JOBVL = 'V', LDVL >= N.\n*\n*  VR      (output) COMPLEX*16 array, dimension (LDVR,N)\n*          If JOBVR = 'V', the right generalized eigenvectors v(j) are\n*          stored one after another in the columns of VR, in the same\n*          order as their eigenvalues.\n*          Each eigenvector will be scaled so the largest component\n*          will have abs(real part) + abs(imag. part) = 1.\n*          Not referenced if JOBVR = 'N'.\n*\n*  LDVR    (input) INTEGER\n*          The leading dimension of the matrix VR. LDVR >= 1, and\n*          if JOBVR = 'V', LDVR >= N.\n*\n*  ILO     (output) INTEGER\n*  IHI     (output) INTEGER\n*          ILO and IHI are integer values such that on exit\n*          A(i,j) = 0 and B(i,j) = 0 if i > j and\n*          j = 1,...,ILO-1 or i = IHI+1,...,N.\n*          If BALANC = 'N' or 'S', ILO = 1 and IHI = N.\n*\n*  LSCALE  (output) DOUBLE PRECISION array, dimension (N)\n*          Details of the permutations and scaling factors applied\n*          to the left side of A and B.  If PL(j) is the index of the\n*          row interchanged with row j, and DL(j) is the scaling\n*          factor applied to row j, then\n*            LSCALE(j) = PL(j)  for j = 1,...,ILO-1\n*                      = DL(j)  for j = ILO,...,IHI\n*                      = PL(j)  for j = IHI+1,...,N.\n*          The order in which the interchanges are made is N to IHI+1,\n*          then 1 to ILO-1.\n*\n*  RSCALE  (output) DOUBLE PRECISION array, dimension (N)\n*          Details of the permutations and scaling factors applied\n*          to the right side of A and B.  If PR(j) is the index of the\n*          column interchanged with column j, and DR(j) is the scaling\n*          factor applied to column j, then\n*            RSCALE(j) = PR(j)  for j = 1,...,ILO-1\n*                      = DR(j)  for j = ILO,...,IHI\n*                      = PR(j)  for j = IHI+1,...,N\n*          The order in which the interchanges are made is N to IHI+1,\n*          then 1 to ILO-1.\n*\n*  ABNRM   (output) DOUBLE PRECISION\n*          The one-norm of the balanced matrix A.\n*\n*  BBNRM   (output) DOUBLE PRECISION\n*          The one-norm of the balanced matrix B.\n*\n*  RCONDE  (output) DOUBLE PRECISION array, dimension (N)\n*          If SENSE = 'E' or 'B', the reciprocal condition numbers of\n*          the eigenvalues, stored in consecutive elements of the array.\n*          If SENSE = 'N' or 'V', RCONDE is not referenced.\n*\n*  RCONDV  (output) DOUBLE PRECISION array, dimension (N)\n*          If JOB = 'V' or 'B', the estimated reciprocal condition\n*          numbers of the eigenvectors, stored in consecutive elements\n*          of the array. If the eigenvalues cannot be reordered to\n*          compute RCONDV(j), RCONDV(j) is set to 0; this can only occur\n*          when the true value would be very small anyway.\n*          If SENSE = 'N' or 'E', RCONDV is not referenced.\n*\n*  WORK    (workspace/output) COMPLEX*16 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,2*N).\n*          If SENSE = 'E', LWORK >= max(1,4*N).\n*          If SENSE = 'V' or 'B', LWORK >= max(1,2*N*N+2*N).\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*  RWORK   (workspace) REAL array, dimension (lrwork)\n*          lrwork must be at least max(1,6*N) if BALANC = 'S' or 'B',\n*          and at least max(1,2*N) otherwise.\n*          Real workspace.\n*\n*  IWORK   (workspace) INTEGER array, dimension (N+2)\n*          If SENSE = 'E', IWORK is not referenced.\n*\n*  BWORK   (workspace) LOGICAL array, dimension (N)\n*          If SENSE = 'N', BWORK is not referenced.\n*\n*  INFO    (output) INTEGER\n*          = 0:  successful exit\n*          < 0:  if INFO = -i, the i-th argument had an illegal value.\n*          = 1,...,N:\n*                The QZ iteration failed.  No eigenvectors have been\n*                calculated, but ALPHA(j) and BETA(j) should be correct\n*                for j=INFO+1,...,N.\n*          > N:  =N+1: other than QZ iteration failed in ZHGEQZ.\n*                =N+2: error return from ZTGEVC.\n*\n\n*  Further Details\n*  ===============\n*\n*  Balancing a matrix pair (A,B) includes, first, permuting rows and\n*  columns to isolate eigenvalues, second, applying diagonal similarity\n*  transformation to the rows and columns to make the rows and columns\n*  as close in norm as possible. The computed reciprocal condition\n*  numbers correspond to the balanced matrix. Permuting rows and columns\n*  will not change the condition numbers (in exact arithmetic) but\n*  diagonal scaling will.  For further explanation of balancing, see\n*  section 4.11.1.2 of LAPACK Users' Guide.\n*\n*  An approximate error bound on the chordal distance between the i-th\n*  computed generalized eigenvalue w and the corresponding exact\n*  eigenvalue lambda is\n*\n*       chord(w, lambda) <= EPS * norm(ABNRM, BBNRM) / RCONDE(I)\n*\n*  An approximate error bound for the angle between the i-th computed\n*  eigenvector VL(i) or VR(i) is given by\n*\n*       EPS * norm(ABNRM, BBNRM) / DIF(i).\n*\n*  For further explanation of the reciprocal condition numbers RCONDE\n*  and RCONDV, see section 4.11 of LAPACK User's Guide.\n*\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  alpha, beta, vl, vr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, info, a, b = NumRu::Lapack.zggevx( balanc, jobvl, jobvr, sense, a, b, [:lwork => lwork, :usage => usage, :help => help])\n");
+      return Qnil;
+    } 
+  } else
+    rblapack_options = Qnil;
+  if (argc != 6 && argc != 7)
+    rb_raise(rb_eArgError,"wrong number of arguments (%d for 6)", argc);
+  rblapack_balanc = argv[0];
+  rblapack_jobvl = argv[1];
+  rblapack_jobvr = argv[2];
+  rblapack_sense = argv[3];
+  rblapack_a = argv[4];
+  rblapack_b = argv[5];
+  if (argc == 7) {
+    rblapack_lwork = argv[6];
+  } else if (rblapack_options != Qnil) {
+    rblapack_lwork = rb_hash_aref(rblapack_options, ID2SYM(rb_intern("lwork")));
+  } else {
+    rblapack_lwork = Qnil;
+  }
+
+  balanc = StringValueCStr(rblapack_balanc)[0];
+  jobvr = StringValueCStr(rblapack_jobvr)[0];
+  if (!NA_IsNArray(rblapack_a))
+    rb_raise(rb_eArgError, "a (5th argument) must be NArray");
+  if (NA_RANK(rblapack_a) != 2)
+    rb_raise(rb_eArgError, "rank of a (5th argument) must be %d", 2);
+  lda = NA_SHAPE0(rblapack_a);
+  n = NA_SHAPE1(rblapack_a);
+  if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
+    rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
+  a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
+  jobvl = StringValueCStr(rblapack_jobvl)[0];
+  if (!NA_IsNArray(rblapack_b))
+    rb_raise(rb_eArgError, "b (6th argument) must be NArray");
+  if (NA_RANK(rblapack_b) != 2)
+    rb_raise(rb_eArgError, "rank of b (6th argument) must be %d", 2);
+  ldb = NA_SHAPE0(rblapack_b);
+  if (NA_SHAPE1(rblapack_b) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of b must be the same as shape 1 of a");
+  if (NA_TYPE(rblapack_b) != NA_DCOMPLEX)
+    rblapack_b = na_change_type(rblapack_b, NA_DCOMPLEX);
+  b = NA_PTR_TYPE(rblapack_b, doublecomplex*);
+  ldvr = lsame_(&jobvr,"V") ? n : 1;
+  ldvl = lsame_(&jobvl,"V") ? n : 1;
+  sense = StringValueCStr(rblapack_sense)[0];
+  lrwork = ((lsame_(&balanc,"S")) || (lsame_(&balanc,"B"))) ? MAX(1,6*n) : MAX(1,2*n);
+  if (rblapack_lwork == Qnil)
+    lwork = lsame_(&sense,"E") ? 4*n : (lsame_(&sense,"V")||lsame_(&sense,"B")) ? 2*n*n+2*n : 2*n;
+  else {
+    lwork = NUM2INT(rblapack_lwork);
+  }
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_alpha = na_make_object(NA_DCOMPLEX, 1, shape, cNArray);
+  }
+  alpha = NA_PTR_TYPE(rblapack_alpha, doublecomplex*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_beta = na_make_object(NA_DCOMPLEX, 1, shape, cNArray);
+  }
+  beta = NA_PTR_TYPE(rblapack_beta, doublecomplex*);
+  {
+    na_shape_t shape[2];
+    shape[0] = ldvl;
+    shape[1] = n;
+    rblapack_vl = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
+  }
+  vl = NA_PTR_TYPE(rblapack_vl, doublecomplex*);
+  {
+    na_shape_t shape[2];
+    shape[0] = ldvr;
+    shape[1] = n;
+    rblapack_vr = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
+  }
+  vr = NA_PTR_TYPE(rblapack_vr, doublecomplex*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_lscale = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  lscale = NA_PTR_TYPE(rblapack_lscale, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_rscale = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  rscale = NA_PTR_TYPE(rblapack_rscale, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_rconde = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  rconde = NA_PTR_TYPE(rblapack_rconde, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_rcondv = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  }
+  rcondv = NA_PTR_TYPE(rblapack_rcondv, doublereal*);
+  {
+    na_shape_t shape[1];
+    shape[0] = MAX(1,lwork);
+    rblapack_work = na_make_object(NA_DCOMPLEX, 1, shape, cNArray);
+  }
+  work = NA_PTR_TYPE(rblapack_work, doublecomplex*);
+  {
+    na_shape_t shape[2];
+    shape[0] = lda;
+    shape[1] = n;
+    rblapack_a_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
+  }
+  a_out__ = NA_PTR_TYPE(rblapack_a_out__, doublecomplex*);
+  MEMCPY(a_out__, a, doublecomplex, NA_TOTAL(rblapack_a));
+  rblapack_a = rblapack_a_out__;
+  a = a_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = ldb;
+    shape[1] = n;
+    rblapack_b_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
+  }
+  b_out__ = NA_PTR_TYPE(rblapack_b_out__, doublecomplex*);
+  MEMCPY(b_out__, b, doublecomplex, NA_TOTAL(rblapack_b));
+  rblapack_b = rblapack_b_out__;
+  b = b_out__;
+  rwork = ALLOC_N(doublereal, (lrwork));
+  iwork = ALLOC_N(integer, (lsame_(&sense,"E") ? 0 : n+2));
+  bwork = ALLOC_N(logical, (lsame_(&sense,"N") ? 0 : n));
+
+  zggevx_(&balanc, &jobvl, &jobvr, &sense, &n, a, &lda, b, &ldb, alpha, beta, vl, &ldvl, vr, &ldvr, &ilo, &ihi, lscale, rscale, &abnrm, &bbnrm, rconde, rcondv, work, &lwork, rwork, iwork, bwork, &info);
+
+  free(rwork);
+  free(iwork);
+  free(bwork);
+  rblapack_ilo = INT2NUM(ilo);
+  rblapack_ihi = INT2NUM(ihi);
+  rblapack_abnrm = rb_float_new((double)abnrm);
+  rblapack_bbnrm = rb_float_new((double)bbnrm);
+  rblapack_info = INT2NUM(info);
+  return rb_ary_new3(16, rblapack_alpha, rblapack_beta, rblapack_vl, rblapack_vr, rblapack_ilo, rblapack_ihi, rblapack_lscale, rblapack_rscale, rblapack_abnrm, rblapack_bbnrm, rblapack_rconde, rblapack_rcondv, rblapack_work, rblapack_info, rblapack_a, rblapack_b);
+}
+
+void
+init_lapack_zggevx(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "zggevx", rblapack_zggevx, -1);
+}

data/ext/zggglm.c

@@ -0,0 +1,156 @@
+#include "rb_lapack.h"
+
+extern VOID zggglm_(integer* n, integer* m, integer* p, doublecomplex* a, integer* lda, doublecomplex* b, integer* ldb, doublecomplex* d, doublecomplex* x, doublecomplex* y, doublecomplex* work, integer* lwork, integer* info);
+
+
+static VALUE
+rblapack_zggglm(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_a;
+  doublecomplex *a; 
+  VALUE rblapack_b;
+  doublecomplex *b; 
+  VALUE rblapack_d;
+  doublecomplex *d; 
+  VALUE rblapack_lwork;
+  integer lwork; 
+  VALUE rblapack_x;
+  doublecomplex *x; 
+  VALUE rblapack_y;
+  doublecomplex *y; 
+  VALUE rblapack_work;
+  doublecomplex *work; 
+  VALUE rblapack_info;
+  integer info; 
+  VALUE rblapack_a_out__;
+  doublecomplex *a_out__;
+  VALUE rblapack_b_out__;
+  doublecomplex *b_out__;
+  VALUE rblapack_d_out__;
+  doublecomplex *d_out__;
+
+  integer lda;
+  integer m;
+  integer ldb;
+  integer p;
+  integer n;
+
+  VALUE rblapack_options;
+  if (argc > 0 && TYPE(argv[argc-1]) == T_HASH) {
+    argc--;
+    rblapack_options = argv[argc];
+    if (rb_hash_aref(rblapack_options, sHelp) == Qtrue) {
+      printf("%s\n", "USAGE:\n  x, y, work, info, a, b, d = NumRu::Lapack.zggglm( a, b, d, [:lwork => lwork, :usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE ZGGGLM( N, M, P, A, LDA, B, LDB, D, X, Y, WORK, LWORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  ZGGGLM solves a general Gauss-Markov linear model (GLM) problem:\n*\n*          minimize || y ||_2   subject to   d = A*x + B*y\n*              x\n*\n*  where A is an N-by-M matrix, B is an N-by-P matrix, and d is a\n*  given N-vector. It is assumed that M <= N <= M+P, and\n*\n*             rank(A) = M    and    rank( A B ) = N.\n*\n*  Under these assumptions, the constrained equation is always\n*  consistent, and there is a unique solution x and a minimal 2-norm\n*  solution y, which is obtained using a generalized QR factorization\n*  of the matrices (A, B) given by\n*\n*     A = Q*(R),   B = Q*T*Z.\n*           (0)\n*\n*  In particular, if matrix B is square nonsingular, then the problem\n*  GLM is equivalent to the following weighted linear least squares\n*  problem\n*\n*               minimize || inv(B)*(d-A*x) ||_2\n*                   x\n*\n*  where inv(B) denotes the inverse of B.\n*\n\n*  Arguments\n*  =========\n*\n*  N       (input) INTEGER\n*          The number of rows of the matrices A and B.  N >= 0.\n*\n*  M       (input) INTEGER\n*          The number of columns of the matrix A.  0 <= M <= N.\n*\n*  P       (input) INTEGER\n*          The number of columns of the matrix B.  P >= N-M.\n*\n*  A       (input/output) COMPLEX*16 array, dimension (LDA,M)\n*          On entry, the N-by-M matrix A.\n*          On exit, the upper triangular part of the array A contains\n*          the M-by-M upper triangular matrix R.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A. LDA >= max(1,N).\n*\n*  B       (input/output) COMPLEX*16 array, dimension (LDB,P)\n*          On entry, the N-by-P matrix B.\n*          On exit, if N <= P, the upper triangle of the subarray\n*          B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T;\n*          if N > P, the elements on and above the (N-P)th subdiagonal\n*          contain the N-by-P upper trapezoidal matrix T.\n*\n*  LDB     (input) INTEGER\n*          The leading dimension of the array B. LDB >= max(1,N).\n*\n*  D       (input/output) COMPLEX*16 array, dimension (N)\n*          On entry, D is the left hand side of the GLM equation.\n*          On exit, D is destroyed.\n*\n*  X       (output) COMPLEX*16 array, dimension (M)\n*  Y       (output) COMPLEX*16 array, dimension (P)\n*          On exit, X and Y are the solutions of the GLM problem.\n*\n*  WORK    (workspace/output) COMPLEX*16 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+M+P).\n*          For optimum performance, LWORK >= M+min(N,P)+max(N,P)*NB,\n*          where NB is an upper bound for the optimal blocksizes for\n*          ZGEQRF, ZGERQF, ZUNMQR and ZUNMRQ.\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*          = 1:  the upper triangular factor R associated with A in the\n*                generalized QR factorization of the pair (A, B) is\n*                singular, so that rank(A) < M; the least squares\n*                solution could not be computed.\n*          = 2:  the bottom (N-M) by (N-M) part of the upper trapezoidal\n*                factor T associated with B in the generalized QR\n*                factorization of the pair (A, B) is singular, so that\n*                rank( A B ) < N; the least squares solution could not\n*                be computed.\n*\n\n*  ===================================================================\n*\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  x, y, work, info, a, b, d = NumRu::Lapack.zggglm( a, b, d, [: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_a = argv[0];
+  rblapack_b = argv[1];
+  rblapack_d = 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;
+  }
+
+  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);
+  m = NA_SHAPE1(rblapack_a);
+  if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
+    rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
+  a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
+  if (!NA_IsNArray(rblapack_d))
+    rb_raise(rb_eArgError, "d (3th argument) must be NArray");
+  if (NA_RANK(rblapack_d) != 1)
+    rb_raise(rb_eArgError, "rank of d (3th argument) must be %d", 1);
+  n = NA_SHAPE0(rblapack_d);
+  if (NA_TYPE(rblapack_d) != NA_DCOMPLEX)
+    rblapack_d = na_change_type(rblapack_d, NA_DCOMPLEX);
+  d = NA_PTR_TYPE(rblapack_d, doublecomplex*);
+  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);
+  ldb = NA_SHAPE0(rblapack_b);
+  p = NA_SHAPE1(rblapack_b);
+  if (NA_TYPE(rblapack_b) != NA_DCOMPLEX)
+    rblapack_b = na_change_type(rblapack_b, NA_DCOMPLEX);
+  b = NA_PTR_TYPE(rblapack_b, doublecomplex*);
+  if (rblapack_lwork == Qnil)
+    lwork = m+n+p;
+  else {
+    lwork = NUM2INT(rblapack_lwork);
+  }
+  {
+    na_shape_t shape[1];
+    shape[0] = m;
+    rblapack_x = na_make_object(NA_DCOMPLEX, 1, shape, cNArray);
+  }
+  x = NA_PTR_TYPE(rblapack_x, doublecomplex*);
+  {
+    na_shape_t shape[1];
+    shape[0] = p;
+    rblapack_y = na_make_object(NA_DCOMPLEX, 1, shape, cNArray);
+  }
+  y = NA_PTR_TYPE(rblapack_y, doublecomplex*);
+  {
+    na_shape_t shape[1];
+    shape[0] = MAX(1,lwork);
+    rblapack_work = na_make_object(NA_DCOMPLEX, 1, shape, cNArray);
+  }
+  work = NA_PTR_TYPE(rblapack_work, doublecomplex*);
+  {
+    na_shape_t shape[2];
+    shape[0] = lda;
+    shape[1] = m;
+    rblapack_a_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
+  }
+  a_out__ = NA_PTR_TYPE(rblapack_a_out__, doublecomplex*);
+  MEMCPY(a_out__, a, doublecomplex, NA_TOTAL(rblapack_a));
+  rblapack_a = rblapack_a_out__;
+  a = a_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = ldb;
+    shape[1] = p;
+    rblapack_b_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
+  }
+  b_out__ = NA_PTR_TYPE(rblapack_b_out__, doublecomplex*);
+  MEMCPY(b_out__, b, doublecomplex, NA_TOTAL(rblapack_b));
+  rblapack_b = rblapack_b_out__;
+  b = b_out__;
+  {
+    na_shape_t shape[1];
+    shape[0] = n;
+    rblapack_d_out__ = na_make_object(NA_DCOMPLEX, 1, shape, cNArray);
+  }
+  d_out__ = NA_PTR_TYPE(rblapack_d_out__, doublecomplex*);
+  MEMCPY(d_out__, d, doublecomplex, NA_TOTAL(rblapack_d));
+  rblapack_d = rblapack_d_out__;
+  d = d_out__;
+
+  zggglm_(&n, &m, &p, a, &lda, b, &ldb, d, x, y, work, &lwork, &info);
+
+  rblapack_info = INT2NUM(info);
+  return rb_ary_new3(7, rblapack_x, rblapack_y, rblapack_work, rblapack_info, rblapack_a, rblapack_b, rblapack_d);
+}
+
+void
+init_lapack_zggglm(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "zggglm", rblapack_zggglm, -1);
+}

data/ext/zgghrd.c

@@ -0,0 +1,167 @@
+#include "rb_lapack.h"
+
+extern VOID zgghrd_(char* compq, char* compz, integer* n, integer* ilo, integer* ihi, doublecomplex* a, integer* lda, doublecomplex* b, integer* ldb, doublecomplex* q, integer* ldq, doublecomplex* z, integer* ldz, integer* info);
+
+
+static VALUE
+rblapack_zgghrd(int argc, VALUE *argv, VALUE self){
+  VALUE rblapack_compq;
+  char compq; 
+  VALUE rblapack_compz;
+  char compz; 
+  VALUE rblapack_ilo;
+  integer ilo; 
+  VALUE rblapack_ihi;
+  integer ihi; 
+  VALUE rblapack_a;
+  doublecomplex *a; 
+  VALUE rblapack_b;
+  doublecomplex *b; 
+  VALUE rblapack_q;
+  doublecomplex *q; 
+  VALUE rblapack_z;
+  doublecomplex *z; 
+  VALUE rblapack_info;
+  integer info; 
+  VALUE rblapack_a_out__;
+  doublecomplex *a_out__;
+  VALUE rblapack_b_out__;
+  doublecomplex *b_out__;
+  VALUE rblapack_q_out__;
+  doublecomplex *q_out__;
+  VALUE rblapack_z_out__;
+  doublecomplex *z_out__;
+
+  integer lda;
+  integer n;
+  integer ldb;
+  integer ldq;
+  integer ldz;
+
+  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, a, b, q, z = NumRu::Lapack.zgghrd( compq, compz, ilo, ihi, a, b, q, z, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE ZGGHRD( COMPQ, COMPZ, N, ILO, IHI, A, LDA, B, LDB, Q, LDQ, Z, LDZ, INFO )\n\n*  Purpose\n*  =======\n*\n*  ZGGHRD reduces a pair of complex matrices (A,B) to generalized upper\n*  Hessenberg form using unitary transformations, where A is a\n*  general matrix and B is upper triangular.  The form of the\n*  generalized eigenvalue problem is\n*     A*x = lambda*B*x,\n*  and B is typically made upper triangular by computing its QR\n*  factorization and moving the unitary matrix Q to the left side\n*  of the equation.\n*\n*  This subroutine simultaneously reduces A to a Hessenberg matrix H:\n*     Q**H*A*Z = H\n*  and transforms B to another upper triangular matrix T:\n*     Q**H*B*Z = T\n*  in order to reduce the problem to its standard form\n*     H*y = lambda*T*y\n*  where y = Z**H*x.\n*\n*  The unitary matrices Q and Z are determined as products of Givens\n*  rotations.  They may either be formed explicitly, or they may be\n*  postmultiplied into input matrices Q1 and Z1, so that\n*       Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H\n*       Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H\n*  If Q1 is the unitary matrix from the QR factorization of B in the\n*  original equation A*x = lambda*B*x, then ZGGHRD reduces the original\n*  problem to generalized Hessenberg form.\n*\n\n*  Arguments\n*  =========\n*\n*  COMPQ   (input) CHARACTER*1\n*          = 'N': do not compute Q;\n*          = 'I': Q is initialized to the unit matrix, and the\n*                 unitary matrix Q is returned;\n*          = 'V': Q must contain a unitary matrix Q1 on entry,\n*                 and the product Q1*Q is returned.\n*\n*  COMPZ   (input) CHARACTER*1\n*          = 'N': do not compute Q;\n*          = 'I': Q is initialized to the unit matrix, and the\n*                 unitary matrix Q is returned;\n*          = 'V': Q must contain a unitary matrix Q1 on entry,\n*                 and the product Q1*Q is returned.\n*\n*  N       (input) INTEGER\n*          The order of the matrices A and B.  N >= 0.\n*\n*  ILO     (input) INTEGER\n*  IHI     (input) INTEGER\n*          ILO and IHI mark the rows and columns of A which are to be\n*          reduced.  It is assumed that A is already upper triangular\n*          in rows and columns 1:ILO-1 and IHI+1:N.  ILO and IHI are\n*          normally set by a previous call to ZGGBAL; otherwise they\n*          should be set to 1 and N respectively.\n*          1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.\n*\n*  A       (input/output) COMPLEX*16 array, dimension (LDA, N)\n*          On entry, the N-by-N general matrix to be reduced.\n*          On exit, the upper triangle and the first subdiagonal of A\n*          are overwritten with the upper Hessenberg matrix H, and the\n*          rest is set to zero.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A.  LDA >= max(1,N).\n*\n*  B       (input/output) COMPLEX*16 array, dimension (LDB, N)\n*          On entry, the N-by-N upper triangular matrix B.\n*          On exit, the upper triangular matrix T = Q**H B Z.  The\n*          elements below the diagonal are set to zero.\n*\n*  LDB     (input) INTEGER\n*          The leading dimension of the array B.  LDB >= max(1,N).\n*\n*  Q       (input/output) COMPLEX*16 array, dimension (LDQ, N)\n*          On entry, if COMPQ = 'V', the unitary matrix Q1, typically\n*          from the QR factorization of B.\n*          On exit, if COMPQ='I', the unitary matrix Q, and if\n*          COMPQ = 'V', the product Q1*Q.\n*          Not referenced if COMPQ='N'.\n*\n*  LDQ     (input) INTEGER\n*          The leading dimension of the array Q.\n*          LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise.\n*\n*  Z       (input/output) COMPLEX*16 array, dimension (LDZ, N)\n*          On entry, if COMPZ = 'V', the unitary matrix Z1.\n*          On exit, if COMPZ='I', the unitary matrix Z, and if\n*          COMPZ = 'V', the product Z1*Z.\n*          Not referenced if COMPZ='N'.\n*\n*  LDZ     (input) INTEGER\n*          The leading dimension of the array Z.\n*          LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise.\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*  This routine reduces A to Hessenberg and B to triangular form by\n*  an unblocked reduction, as described in _Matrix_Computations_,\n*  by Golub and van Loan (Johns Hopkins Press).\n*\n*  =====================================================================\n*\n\n");
+      return Qnil;
+    }
+    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
+      printf("%s\n", "USAGE:\n  info, a, b, q, z = NumRu::Lapack.zgghrd( compq, compz, ilo, ihi, a, b, q, z, [: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_compq = argv[0];
+  rblapack_compz = argv[1];
+  rblapack_ilo = argv[2];
+  rblapack_ihi = argv[3];
+  rblapack_a = argv[4];
+  rblapack_b = argv[5];
+  rblapack_q = argv[6];
+  rblapack_z = argv[7];
+  if (argc == 8) {
+  } else if (rblapack_options != Qnil) {
+  } else {
+  }
+
+  compq = StringValueCStr(rblapack_compq)[0];
+  ilo = NUM2INT(rblapack_ilo);
+  if (!NA_IsNArray(rblapack_a))
+    rb_raise(rb_eArgError, "a (5th argument) must be NArray");
+  if (NA_RANK(rblapack_a) != 2)
+    rb_raise(rb_eArgError, "rank of a (5th argument) must be %d", 2);
+  lda = NA_SHAPE0(rblapack_a);
+  n = NA_SHAPE1(rblapack_a);
+  if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
+    rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
+  a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
+  if (!NA_IsNArray(rblapack_q))
+    rb_raise(rb_eArgError, "q (7th argument) must be NArray");
+  if (NA_RANK(rblapack_q) != 2)
+    rb_raise(rb_eArgError, "rank of q (7th argument) must be %d", 2);
+  ldq = NA_SHAPE0(rblapack_q);
+  if (NA_SHAPE1(rblapack_q) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of q must be the same as shape 1 of a");
+  if (NA_TYPE(rblapack_q) != NA_DCOMPLEX)
+    rblapack_q = na_change_type(rblapack_q, NA_DCOMPLEX);
+  q = NA_PTR_TYPE(rblapack_q, doublecomplex*);
+  compz = StringValueCStr(rblapack_compz)[0];
+  if (!NA_IsNArray(rblapack_b))
+    rb_raise(rb_eArgError, "b (6th argument) must be NArray");
+  if (NA_RANK(rblapack_b) != 2)
+    rb_raise(rb_eArgError, "rank of b (6th argument) must be %d", 2);
+  ldb = NA_SHAPE0(rblapack_b);
+  if (NA_SHAPE1(rblapack_b) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of b must be the same as shape 1 of a");
+  if (NA_TYPE(rblapack_b) != NA_DCOMPLEX)
+    rblapack_b = na_change_type(rblapack_b, NA_DCOMPLEX);
+  b = NA_PTR_TYPE(rblapack_b, doublecomplex*);
+  ihi = NUM2INT(rblapack_ihi);
+  if (!NA_IsNArray(rblapack_z))
+    rb_raise(rb_eArgError, "z (8th argument) must be NArray");
+  if (NA_RANK(rblapack_z) != 2)
+    rb_raise(rb_eArgError, "rank of z (8th argument) must be %d", 2);
+  ldz = NA_SHAPE0(rblapack_z);
+  if (NA_SHAPE1(rblapack_z) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of z must be the same as shape 1 of a");
+  if (NA_TYPE(rblapack_z) != NA_DCOMPLEX)
+    rblapack_z = na_change_type(rblapack_z, NA_DCOMPLEX);
+  z = NA_PTR_TYPE(rblapack_z, doublecomplex*);
+  {
+    na_shape_t shape[2];
+    shape[0] = lda;
+    shape[1] = n;
+    rblapack_a_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
+  }
+  a_out__ = NA_PTR_TYPE(rblapack_a_out__, doublecomplex*);
+  MEMCPY(a_out__, a, doublecomplex, NA_TOTAL(rblapack_a));
+  rblapack_a = rblapack_a_out__;
+  a = a_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = ldb;
+    shape[1] = n;
+    rblapack_b_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
+  }
+  b_out__ = NA_PTR_TYPE(rblapack_b_out__, doublecomplex*);
+  MEMCPY(b_out__, b, doublecomplex, NA_TOTAL(rblapack_b));
+  rblapack_b = rblapack_b_out__;
+  b = b_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = ldq;
+    shape[1] = n;
+    rblapack_q_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
+  }
+  q_out__ = NA_PTR_TYPE(rblapack_q_out__, doublecomplex*);
+  MEMCPY(q_out__, q, doublecomplex, NA_TOTAL(rblapack_q));
+  rblapack_q = rblapack_q_out__;
+  q = q_out__;
+  {
+    na_shape_t shape[2];
+    shape[0] = ldz;
+    shape[1] = n;
+    rblapack_z_out__ = na_make_object(NA_DCOMPLEX, 2, shape, cNArray);
+  }
+  z_out__ = NA_PTR_TYPE(rblapack_z_out__, doublecomplex*);
+  MEMCPY(z_out__, z, doublecomplex, NA_TOTAL(rblapack_z));
+  rblapack_z = rblapack_z_out__;
+  z = z_out__;
+
+  zgghrd_(&compq, &compz, &n, &ilo, &ihi, a, &lda, b, &ldb, q, &ldq, z, &ldz, &info);
+
+  rblapack_info = INT2NUM(info);
+  return rb_ary_new3(5, rblapack_info, rblapack_a, rblapack_b, rblapack_q, rblapack_z);
+}
+
+void
+init_lapack_zgghrd(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
+  sHelp = sH;
+  sUsage = sU;
+  rblapack_ZERO = zero;
+
+  rb_define_module_function(mLapack, "zgghrd", rblapack_zgghrd, -1);
+}