ruby-lapack 1.6 → 1.7

data/ext/cstemr.c

@@ -1,193 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID cstemr_(char* jobz, char* range, integer* n, real* d, real* e, real* vl, real* vu, integer* il, integer* iu, integer* m, real* w, complex* z, integer* ldz, integer* nzc, integer* isuppz, logical* tryrac, real* work, integer* lwork, integer* iwork, integer* liwork, integer* info);
-
-
-static VALUE
-rblapack_cstemr(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_jobz;
-  char jobz; 
-  VALUE rblapack_range;
-  char range; 
-  VALUE rblapack_d;
-  real *d; 
-  VALUE rblapack_e;
-  real *e; 
-  VALUE rblapack_vl;
-  real vl; 
-  VALUE rblapack_vu;
-  real vu; 
-  VALUE rblapack_il;
-  integer il; 
-  VALUE rblapack_iu;
-  integer iu; 
-  VALUE rblapack_nzc;
-  integer nzc; 
-  VALUE rblapack_tryrac;
-  logical tryrac; 
-  VALUE rblapack_lwork;
-  integer lwork; 
-  VALUE rblapack_liwork;
-  integer liwork; 
-  VALUE rblapack_m;
-  integer m; 
-  VALUE rblapack_w;
-  real *w; 
-  VALUE rblapack_z;
-  complex *z; 
-  VALUE rblapack_isuppz;
-  integer *isuppz; 
-  VALUE rblapack_work;
-  real *work; 
-  VALUE rblapack_iwork;
-  integer *iwork; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack_d_out__;
-  real *d_out__;
-  VALUE rblapack_e_out__;
-  real *e_out__;
-
-  integer n;
-  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  m, w, z, isuppz, work, iwork, info, d, e, tryrac = NumRu::Lapack.cstemr( jobz, range, d, e, vl, vu, il, iu, nzc, tryrac, [:lwork => lwork, :liwork => liwork, :usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE CSTEMR( JOBZ, RANGE, N, D, E, VL, VU, IL, IU, M, W, Z, LDZ, NZC, ISUPPZ, TRYRAC, WORK, LWORK, IWORK, LIWORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  CSTEMR computes selected eigenvalues and, optionally, eigenvectors\n*  of a real symmetric tridiagonal matrix T. Any such unreduced matrix has\n*  a well defined set of pairwise different real eigenvalues, the corresponding\n*  real eigenvectors are pairwise orthogonal.\n*\n*  The spectrum may be computed either completely or partially by specifying\n*  either an interval (VL,VU] or a range of indices IL:IU for the desired\n*  eigenvalues.\n*\n*  Depending on the number of desired eigenvalues, these are computed either\n*  by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are\n*  computed by the use of various suitable L D L^T factorizations near clusters\n*  of close eigenvalues (referred to as RRRs, Relatively Robust\n*  Representations). An informal sketch of the algorithm follows.\n*\n*  For each unreduced block (submatrix) of T,\n*     (a) Compute T - sigma I  = L D L^T, so that L and D\n*         define all the wanted eigenvalues to high relative accuracy.\n*         This means that small relative changes in the entries of D and L\n*         cause only small relative changes in the eigenvalues and\n*         eigenvectors. The standard (unfactored) representation of the\n*         tridiagonal matrix T does not have this property in general.\n*     (b) Compute the eigenvalues to suitable accuracy.\n*         If the eigenvectors are desired, the algorithm attains full\n*         accuracy of the computed eigenvalues only right before\n*         the corresponding vectors have to be computed, see steps c) and d).\n*     (c) For each cluster of close eigenvalues, select a new\n*         shift close to the cluster, find a new factorization, and refine\n*         the shifted eigenvalues to suitable accuracy.\n*     (d) For each eigenvalue with a large enough relative separation compute\n*         the corresponding eigenvector by forming a rank revealing twisted\n*         factorization. Go back to (c) for any clusters that remain.\n*\n*  For more details, see:\n*  - Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations\n*    to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"\n*    Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.\n*  - Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and\n*    Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,\n*    2004.  Also LAPACK Working Note 154.\n*  - Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric\n*    tridiagonal eigenvalue/eigenvector problem\",\n*    Computer Science Division Technical Report No. UCB/CSD-97-971,\n*    UC Berkeley, May 1997.\n*\n*  Further Details\n*  1.CSTEMR works only on machines which follow IEEE-754\n*  floating-point standard in their handling of infinities and NaNs.\n*  This permits the use of efficient inner loops avoiding a check for\n*  zero divisors.\n*\n*  2. LAPACK routines can be used to reduce a complex Hermitean matrix to\n*  real symmetric tridiagonal form.\n*\n*  (Any complex Hermitean tridiagonal matrix has real values on its diagonal\n*  and potentially complex numbers on its off-diagonals. By applying a\n*  similarity transform with an appropriate diagonal matrix\n*  diag(1,e^{i \\phy_1}, ... , e^{i \\phy_{n-1}}), the complex Hermitean\n*  matrix can be transformed into a real symmetric matrix and complex\n*  arithmetic can be entirely avoided.)\n*\n*  While the eigenvectors of the real symmetric tridiagonal matrix are real,\n*  the eigenvectors of original complex Hermitean matrix have complex entries\n*  in general.\n*  Since LAPACK drivers overwrite the matrix data with the eigenvectors,\n*  CSTEMR accepts complex workspace to facilitate interoperability\n*  with CUNMTR or CUPMTR.\n*\n\n*  Arguments\n*  =========\n*\n*  JOBZ    (input) CHARACTER*1\n*          = 'N':  Compute eigenvalues only;\n*          = 'V':  Compute eigenvalues and eigenvectors.\n*\n*  RANGE   (input) CHARACTER*1\n*          = 'A': all eigenvalues will be found.\n*          = 'V': all eigenvalues in the half-open interval (VL,VU]\n*                 will be found.\n*          = 'I': the IL-th through IU-th eigenvalues will be found.\n*\n*  N       (input) INTEGER\n*          The order of the matrix.  N >= 0.\n*\n*  D       (input/output) REAL array, dimension (N)\n*          On entry, the N diagonal elements of the tridiagonal matrix\n*          T. On exit, D is overwritten.\n*\n*  E       (input/output) REAL array, dimension (N)\n*          On entry, the (N-1) subdiagonal elements of the tridiagonal\n*          matrix T in elements 1 to N-1 of E. E(N) need not be set on\n*          input, but is used internally as workspace.\n*          On exit, E is overwritten.\n*\n*  VL      (input) REAL\n*  VU      (input) REAL\n*          If RANGE='V', the lower and upper bounds of the interval to\n*          be searched for eigenvalues. VL < VU.\n*          Not referenced if RANGE = 'A' or 'I'.\n*\n*  IL      (input) INTEGER\n*  IU      (input) INTEGER\n*          If RANGE='I', the indices (in ascending order) of the\n*          smallest and largest eigenvalues to be returned.\n*          1 <= IL <= IU <= N, if N > 0.\n*          Not referenced if RANGE = 'A' or 'V'.\n*\n*  M       (output) INTEGER\n*          The total number of eigenvalues found.  0 <= M <= N.\n*          If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1.\n*\n*  W       (output) REAL array, dimension (N)\n*          The first M elements contain the selected eigenvalues in\n*          ascending order.\n*\n*  Z       (output) COMPLEX array, dimension (LDZ, max(1,M) )\n*          If JOBZ = 'V', and if INFO = 0, then the first M columns of Z\n*          contain the orthonormal eigenvectors of the matrix T\n*          corresponding to the selected eigenvalues, with the i-th\n*          column of Z holding the eigenvector associated with W(i).\n*          If JOBZ = 'N', then Z is not referenced.\n*          Note: the user must ensure that at least max(1,M) columns are\n*          supplied in the array Z; if RANGE = 'V', the exact value of M\n*          is not known in advance and can be computed with a workspace\n*          query by setting NZC = -1, see below.\n*\n*  LDZ     (input) INTEGER\n*          The leading dimension of the array Z.  LDZ >= 1, and if\n*          JOBZ = 'V', then LDZ >= max(1,N).\n*\n*  NZC     (input) INTEGER\n*          The number of eigenvectors to be held in the array Z.\n*          If RANGE = 'A', then NZC >= max(1,N).\n*          If RANGE = 'V', then NZC >= the number of eigenvalues in (VL,VU].\n*          If RANGE = 'I', then NZC >= IU-IL+1.\n*          If NZC = -1, then a workspace query is assumed; the\n*          routine calculates the number of columns of the array Z that\n*          are needed to hold the eigenvectors.\n*          This value is returned as the first entry of the Z array, and\n*          no error message related to NZC is issued by XERBLA.\n*\n*  ISUPPZ  (output) INTEGER ARRAY, dimension ( 2*max(1,M) )\n*          The support of the eigenvectors in Z, i.e., the indices\n*          indicating the nonzero elements in Z. The i-th computed eigenvector\n*          is nonzero only in elements ISUPPZ( 2*i-1 ) through\n*          ISUPPZ( 2*i ). This is relevant in the case when the matrix\n*          is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0.\n*\n*  TRYRAC  (input/output) LOGICAL\n*          If TRYRAC.EQ..TRUE., indicates that the code should check whether\n*          the tridiagonal matrix defines its eigenvalues to high relative\n*          accuracy.  If so, the code uses relative-accuracy preserving\n*          algorithms that might be (a bit) slower depending on the matrix.\n*          If the matrix does not define its eigenvalues to high relative\n*          accuracy, the code can uses possibly faster algorithms.\n*          If TRYRAC.EQ..FALSE., the code is not required to guarantee\n*          relatively accurate eigenvalues and can use the fastest possible\n*          techniques.\n*          On exit, a .TRUE. TRYRAC will be set to .FALSE. if the matrix\n*          does not define its eigenvalues to high relative accuracy.\n*\n*  WORK    (workspace/output) REAL array, dimension (LWORK)\n*          On exit, if INFO = 0, WORK(1) returns the optimal\n*          (and minimal) LWORK.\n*\n*  LWORK   (input) INTEGER\n*          The dimension of the array WORK. LWORK >= max(1,18*N)\n*          if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = '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*  IWORK   (workspace/output) INTEGER array, dimension (LIWORK)\n*          On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.\n*\n*  LIWORK  (input) INTEGER\n*          The dimension of the array IWORK.  LIWORK >= max(1,10*N)\n*          if the eigenvectors are desired, and LIWORK >= max(1,8*N)\n*          if only the eigenvalues are to be computed.\n*          If LIWORK = -1, then a workspace query is assumed; the\n*          routine only calculates the optimal size of the IWORK array,\n*          returns this value as the first entry of the IWORK array, and\n*          no error message related to LIWORK is issued by XERBLA.\n*\n*  INFO    (output) INTEGER\n*          On exit, INFO\n*          = 0:  successful exit\n*          < 0:  if INFO = -i, the i-th argument had an illegal value\n*          > 0:  if INFO = 1X, internal error in SLARRE,\n*                if INFO = 2X, internal error in CLARRV.\n*                Here, the digit X = ABS( IINFO ) < 10, where IINFO is\n*                the nonzero error code returned by SLARRE or\n*                CLARRV, respectively.\n*\n*\n\n*  Further Details\n*  ===============\n*\n*  Based on contributions by\n*     Beresford Parlett, University of California, Berkeley, USA\n*     Jim Demmel, University of California, Berkeley, USA\n*     Inderjit Dhillon, University of Texas, Austin, USA\n*     Osni Marques, LBNL/NERSC, USA\n*     Christof Voemel, University of California, Berkeley, USA\n*\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  m, w, z, isuppz, work, iwork, info, d, e, tryrac = NumRu::Lapack.cstemr( jobz, range, d, e, vl, vu, il, iu, nzc, tryrac, [:lwork => lwork, :liwork => liwork, :usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 10 && argc != 12)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 10)", argc);
-  rblapack_jobz = argv[0];
-  rblapack_range = argv[1];
-  rblapack_d = argv[2];
-  rblapack_e = argv[3];
-  rblapack_vl = argv[4];
-  rblapack_vu = argv[5];
-  rblapack_il = argv[6];
-  rblapack_iu = argv[7];
-  rblapack_nzc = argv[8];
-  rblapack_tryrac = argv[9];
-  if (argc == 12) {
-    rblapack_lwork = argv[10];
-    rblapack_liwork = argv[11];
-  } else if (rblapack_options != Qnil) {
-    rblapack_lwork = rb_hash_aref(rblapack_options, ID2SYM(rb_intern("lwork")));
-    rblapack_liwork = rb_hash_aref(rblapack_options, ID2SYM(rb_intern("liwork")));
-  } else {
-    rblapack_lwork = Qnil;
-    rblapack_liwork = Qnil;
-  }
-
-  jobz = StringValueCStr(rblapack_jobz)[0];
-  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_SFLOAT)
-    rblapack_d = na_change_type(rblapack_d, NA_SFLOAT);
-  d = NA_PTR_TYPE(rblapack_d, real*);
-  vl = (real)NUM2DBL(rblapack_vl);
-  il = NUM2INT(rblapack_il);
-  nzc = NUM2INT(rblapack_nzc);
-  range = StringValueCStr(rblapack_range)[0];
-  vu = (real)NUM2DBL(rblapack_vu);
-  tryrac = (rblapack_tryrac == Qtrue);
-  if (!NA_IsNArray(rblapack_e))
-    rb_raise(rb_eArgError, "e (4th argument) must be NArray");
-  if (NA_RANK(rblapack_e) != 1)
-    rb_raise(rb_eArgError, "rank of e (4th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_e) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of e must be the same as shape 0 of d");
-  if (NA_TYPE(rblapack_e) != NA_SFLOAT)
-    rblapack_e = na_change_type(rblapack_e, NA_SFLOAT);
-  e = NA_PTR_TYPE(rblapack_e, real*);
-  if (rblapack_lwork == Qnil)
-    lwork = lsame_(&jobz,"V") ? 18*n : lsame_(&jobz,"N") ? 12*n : 0;
-  else {
-    lwork = NUM2INT(rblapack_lwork);
-  }
-  ldz = lsame_(&jobz,"V") ? MAX(1,n) : 1;
-  iu = NUM2INT(rblapack_iu);
-  m = lsame_(&range,"A") ? n : lsame_(&range,"I") ? iu-il+1 : 0;
-  if (rblapack_liwork == Qnil)
-    liwork = lsame_(&jobz,"V") ? 10*n : lsame_(&jobz,"N") ? 8*n : 0;
-  else {
-    liwork = NUM2INT(rblapack_liwork);
-  }
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_w = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  w = NA_PTR_TYPE(rblapack_w, real*);
-  {
-    int shape[2];
-    shape[0] = ldz;
-    shape[1] = MAX(1,m);
-    rblapack_z = na_make_object(NA_SCOMPLEX, 2, shape, cNArray);
-  }
-  z = NA_PTR_TYPE(rblapack_z, complex*);
-  {
-    int shape[1];
-    shape[0] = 2*MAX(1,m);
-    rblapack_isuppz = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  isuppz = NA_PTR_TYPE(rblapack_isuppz, integer*);
-  {
-    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[1];
-    shape[0] = MAX(1,liwork);
-    rblapack_iwork = na_make_object(NA_LINT, 1, shape, cNArray);
-  }
-  iwork = NA_PTR_TYPE(rblapack_iwork, integer*);
-  {
-    int 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__;
-  {
-    int shape[1];
-    shape[0] = n;
-    rblapack_e_out__ = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  e_out__ = NA_PTR_TYPE(rblapack_e_out__, real*);
-  MEMCPY(e_out__, e, real, NA_TOTAL(rblapack_e));
-  rblapack_e = rblapack_e_out__;
-  e = e_out__;
-
-  cstemr_(&jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w, z, &ldz, &nzc, isuppz, &tryrac, work, &lwork, iwork, &liwork, &info);
-
-  rblapack_m = INT2NUM(m);
-  rblapack_info = INT2NUM(info);
-  rblapack_tryrac = tryrac ? Qtrue : Qfalse;
-  return rb_ary_new3(10, rblapack_m, rblapack_w, rblapack_z, rblapack_isuppz, rblapack_work, rblapack_iwork, rblapack_info, rblapack_d, rblapack_e, rblapack_tryrac);
-}
-
-void
-init_lapack_cstemr(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "cstemr", rblapack_cstemr, -1);
-}

data/ext/csteqr.c

@@ -1,126 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID csteqr_(char* compz, integer* n, real* d, real* e, complex* z, integer* ldz, real* work, integer* info);
-
-
-static VALUE
-rblapack_csteqr(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_compz;
-  char compz; 
-  VALUE rblapack_d;
-  real *d; 
-  VALUE rblapack_e;
-  real *e; 
-  VALUE rblapack_z;
-  complex *z; 
-  VALUE rblapack_info;
-  integer info; 
-  VALUE rblapack_d_out__;
-  real *d_out__;
-  VALUE rblapack_e_out__;
-  real *e_out__;
-  VALUE rblapack_z_out__;
-  complex *z_out__;
-  real *work;
-
-  integer n;
-  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, d, e, z = NumRu::Lapack.csteqr( compz, d, e, z, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE CSTEQR( COMPZ, N, D, E, Z, LDZ, WORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  CSTEQR computes all eigenvalues and, optionally, eigenvectors of a\n*  symmetric tridiagonal matrix using the implicit QL or QR method.\n*  The eigenvectors of a full or band complex Hermitian matrix can also\n*  be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this\n*  matrix to tridiagonal form.\n*\n\n*  Arguments\n*  =========\n*\n*  COMPZ   (input) CHARACTER*1\n*          = 'N':  Compute eigenvalues only.\n*          = 'V':  Compute eigenvalues and eigenvectors of the original\n*                  Hermitian matrix.  On entry, Z must contain the\n*                  unitary matrix used to reduce the original matrix\n*                  to tridiagonal form.\n*          = 'I':  Compute eigenvalues and eigenvectors of the\n*                  tridiagonal matrix.  Z is initialized to the identity\n*                  matrix.\n*\n*  N       (input) INTEGER\n*          The order of the matrix.  N >= 0.\n*\n*  D       (input/output) REAL array, dimension (N)\n*          On entry, the diagonal elements of the tridiagonal matrix.\n*          On exit, if INFO = 0, the eigenvalues in ascending order.\n*\n*  E       (input/output) REAL array, dimension (N-1)\n*          On entry, the (n-1) subdiagonal elements of the tridiagonal\n*          matrix.\n*          On exit, E has been destroyed.\n*\n*  Z       (input/output) COMPLEX array, dimension (LDZ, N)\n*          On entry, if  COMPZ = 'V', then Z contains the unitary\n*          matrix used in the reduction to tridiagonal form.\n*          On exit, if INFO = 0, then if COMPZ = 'V', Z contains the\n*          orthonormal eigenvectors of the original Hermitian matrix,\n*          and if COMPZ = 'I', Z contains the orthonormal eigenvectors\n*          of the symmetric tridiagonal matrix.\n*          If COMPZ = 'N', then Z is not referenced.\n*\n*  LDZ     (input) INTEGER\n*          The leading dimension of the array Z.  LDZ >= 1, and if\n*          eigenvectors are desired, then  LDZ >= max(1,N).\n*\n*  WORK    (workspace) REAL array, dimension (max(1,2*N-2))\n*          If COMPZ = 'N', then WORK 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*          > 0:  the algorithm has failed to find all the eigenvalues in\n*                a total of 30*N iterations; if INFO = i, then i\n*                elements of E have not converged to zero; on exit, D\n*                and E contain the elements of a symmetric tridiagonal\n*                matrix which is unitarily similar to the original\n*                matrix.\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  info, d, e, z = NumRu::Lapack.csteqr( compz, d, e, z, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 4 && argc != 4)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 4)", argc);
-  rblapack_compz = argv[0];
-  rblapack_d = argv[1];
-  rblapack_e = argv[2];
-  rblapack_z = argv[3];
-  if (argc == 4) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  compz = StringValueCStr(rblapack_compz)[0];
-  if (!NA_IsNArray(rblapack_z))
-    rb_raise(rb_eArgError, "z (4th argument) must be NArray");
-  if (NA_RANK(rblapack_z) != 2)
-    rb_raise(rb_eArgError, "rank of z (4th argument) must be %d", 2);
-  ldz = NA_SHAPE0(rblapack_z);
-  n = NA_SHAPE1(rblapack_z);
-  if (NA_TYPE(rblapack_z) != NA_SCOMPLEX)
-    rblapack_z = na_change_type(rblapack_z, NA_SCOMPLEX);
-  z = NA_PTR_TYPE(rblapack_z, complex*);
-  if (!NA_IsNArray(rblapack_d))
-    rb_raise(rb_eArgError, "d (2th argument) must be NArray");
-  if (NA_RANK(rblapack_d) != 1)
-    rb_raise(rb_eArgError, "rank of d (2th 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 z");
-  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_e))
-    rb_raise(rb_eArgError, "e (3th argument) must be NArray");
-  if (NA_RANK(rblapack_e) != 1)
-    rb_raise(rb_eArgError, "rank of e (3th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_e) != (n-1))
-    rb_raise(rb_eRuntimeError, "shape 0 of e must be %d", n-1);
-  if (NA_TYPE(rblapack_e) != NA_SFLOAT)
-    rblapack_e = na_change_type(rblapack_e, NA_SFLOAT);
-  e = NA_PTR_TYPE(rblapack_e, real*);
-  {
-    int 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__;
-  {
-    int shape[1];
-    shape[0] = n-1;
-    rblapack_e_out__ = na_make_object(NA_SFLOAT, 1, shape, cNArray);
-  }
-  e_out__ = NA_PTR_TYPE(rblapack_e_out__, real*);
-  MEMCPY(e_out__, e, real, NA_TOTAL(rblapack_e));
-  rblapack_e = rblapack_e_out__;
-  e = e_out__;
-  {
-    int shape[2];
-    shape[0] = ldz;
-    shape[1] = n;
-    rblapack_z_out__ = na_make_object(NA_SCOMPLEX, 2, shape, cNArray);
-  }
-  z_out__ = NA_PTR_TYPE(rblapack_z_out__, complex*);
-  MEMCPY(z_out__, z, complex, NA_TOTAL(rblapack_z));
-  rblapack_z = rblapack_z_out__;
-  z = z_out__;
-  work = ALLOC_N(real, (lsame_(&compz,"N") ? 0 : MAX(1,2*n-2)));
-
-  csteqr_(&compz, &n, d, e, z, &ldz, work, &info);
-
-  free(work);
-  rblapack_info = INT2NUM(info);
-  return rb_ary_new3(4, rblapack_info, rblapack_d, rblapack_e, rblapack_z);
-}
-
-void
-init_lapack_csteqr(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "csteqr", rblapack_csteqr, -1);
-}

data/ext/csycon.c

@@ -1,87 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID csycon_(char* uplo, integer* n, complex* a, integer* lda, integer* ipiv, real* anorm, real* rcond, complex* work, integer* info);
-
-
-static VALUE
-rblapack_csycon(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_uplo;
-  char uplo; 
-  VALUE rblapack_a;
-  complex *a; 
-  VALUE rblapack_ipiv;
-  integer *ipiv; 
-  VALUE rblapack_anorm;
-  real anorm; 
-  VALUE rblapack_rcond;
-  real rcond; 
-  VALUE rblapack_info;
-  integer info; 
-  complex *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  rcond, info = NumRu::Lapack.csycon( uplo, a, ipiv, anorm, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE CSYCON( UPLO, N, A, LDA, IPIV, ANORM, RCOND, WORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  CSYCON estimates the reciprocal of the condition number (in the\n*  1-norm) of a complex symmetric matrix A using the factorization\n*  A = U*D*U**T or A = L*D*L**T computed by CSYTRF.\n*\n*  An estimate is obtained for norm(inv(A)), and the reciprocal of the\n*  condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).\n*\n\n*  Arguments\n*  =========\n*\n*  UPLO    (input) CHARACTER*1\n*          Specifies whether the details of the factorization are stored\n*          as an upper or lower triangular matrix.\n*          = 'U':  Upper triangular, form is A = U*D*U**T;\n*          = 'L':  Lower triangular, form is A = L*D*L**T.\n*\n*  N       (input) INTEGER\n*          The order of the matrix A.  N >= 0.\n*\n*  A       (input) COMPLEX array, dimension (LDA,N)\n*          The block diagonal matrix D and the multipliers used to\n*          obtain the factor U or L as computed by CSYTRF.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A.  LDA >= max(1,N).\n*\n*  IPIV    (input) INTEGER array, dimension (N)\n*          Details of the interchanges and the block structure of D\n*          as determined by CSYTRF.\n*\n*  ANORM   (input) REAL\n*          The 1-norm of the original matrix A.\n*\n*  RCOND   (output) REAL\n*          The reciprocal of the condition number of the matrix A,\n*          computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an\n*          estimate of the 1-norm of inv(A) computed in this routine.\n*\n*  WORK    (workspace) COMPLEX array, dimension (2*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*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  rcond, info = NumRu::Lapack.csycon( uplo, a, ipiv, anorm, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 4 && argc != 4)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 4)", argc);
-  rblapack_uplo = argv[0];
-  rblapack_a = argv[1];
-  rblapack_ipiv = argv[2];
-  rblapack_anorm = argv[3];
-  if (argc == 4) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  uplo = StringValueCStr(rblapack_uplo)[0];
-  if (!NA_IsNArray(rblapack_ipiv))
-    rb_raise(rb_eArgError, "ipiv (3th argument) must be NArray");
-  if (NA_RANK(rblapack_ipiv) != 1)
-    rb_raise(rb_eArgError, "rank of ipiv (3th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_ipiv);
-  if (NA_TYPE(rblapack_ipiv) != NA_LINT)
-    rblapack_ipiv = na_change_type(rblapack_ipiv, NA_LINT);
-  ipiv = NA_PTR_TYPE(rblapack_ipiv, integer*);
-  if (!NA_IsNArray(rblapack_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 ipiv");
-  if (NA_TYPE(rblapack_a) != NA_SCOMPLEX)
-    rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
-  a = NA_PTR_TYPE(rblapack_a, complex*);
-  anorm = (real)NUM2DBL(rblapack_anorm);
-  work = ALLOC_N(complex, (2*n));
-
-  csycon_(&uplo, &n, a, &lda, ipiv, &anorm, &rcond, work, &info);
-
-  free(work);
-  rblapack_rcond = rb_float_new((double)rcond);
-  rblapack_info = INT2NUM(info);
-  return rb_ary_new3(2, rblapack_rcond, rblapack_info);
-}
-
-void
-init_lapack_csycon(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "csycon", rblapack_csycon, -1);
-}

data/ext/csyconv.c

@@ -1,84 +0,0 @@
-#include "rb_lapack.h"
-
-extern VOID csyconv_(char* uplo, char* way, integer* n, complex* a, integer* lda, integer* ipiv, complex* work, integer* info);
-
-
-static VALUE
-rblapack_csyconv(int argc, VALUE *argv, VALUE self){
-  VALUE rblapack_uplo;
-  char uplo; 
-  VALUE rblapack_way;
-  char way; 
-  VALUE rblapack_a;
-  complex *a; 
-  VALUE rblapack_ipiv;
-  integer *ipiv; 
-  VALUE rblapack_info;
-  integer info; 
-  complex *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  info = NumRu::Lapack.csyconv( uplo, way, a, ipiv, [:usage => usage, :help => help])\n\n\nFORTRAN MANUAL\n      SUBROUTINE CSYCONV( UPLO, WAY, N, A, LDA, IPIV, WORK, INFO )\n\n*  Purpose\n*  =======\n*\n*  CSYCONV convert A given by TRF into L and D and vice-versa.\n*  Get Non-diag elements of D (returned in workspace) and \n*  apply or reverse permutation done in TRF.\n*\n\n*  Arguments\n*  =========\n*\n*  UPLO    (input) CHARACTER*1\n*          Specifies whether the details of the factorization are stored\n*          as an upper or lower triangular matrix.\n*          = 'U':  Upper triangular, form is A = U*D*U**T;\n*          = 'L':  Lower triangular, form is A = L*D*L**T.\n* \n*  WAY     (input) CHARACTER*1\n*          = 'C': Convert \n*          = 'R': Revert\n*\n*  N       (input) INTEGER\n*          The order of the matrix A.  N >= 0.\n*\n*  A       (input) COMPLEX array, dimension (LDA,N)\n*          The block diagonal matrix D and the multipliers used to\n*          obtain the factor U or L as computed by CSYTRF.\n*\n*  LDA     (input) INTEGER\n*          The leading dimension of the array A.  LDA >= max(1,N).\n*\n*  IPIV    (input) INTEGER array, dimension (N)\n*          Details of the interchanges and the block structure of D\n*          as determined by CSYTRF.\n*\n* WORK     (workspace) COMPLEX array, dimension (N)\n*\n* LWORK    (input) INTEGER\n*          The length of WORK.  LWORK >=1. \n*          LWORK = 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*  INFO    (output) INTEGER\n*          = 0:  successful exit\n*          < 0:  if INFO = -i, the i-th argument had an illegal value\n*\n\n*  =====================================================================\n*\n\n");
-      return Qnil;
-    }
-    if (rb_hash_aref(rblapack_options, sUsage) == Qtrue) {
-      printf("%s\n", "USAGE:\n  info = NumRu::Lapack.csyconv( uplo, way, a, ipiv, [:usage => usage, :help => help])\n");
-      return Qnil;
-    } 
-  } else
-    rblapack_options = Qnil;
-  if (argc != 4 && argc != 4)
-    rb_raise(rb_eArgError,"wrong number of arguments (%d for 4)", argc);
-  rblapack_uplo = argv[0];
-  rblapack_way = argv[1];
-  rblapack_a = argv[2];
-  rblapack_ipiv = argv[3];
-  if (argc == 4) {
-  } else if (rblapack_options != Qnil) {
-  } else {
-  }
-
-  uplo = StringValueCStr(rblapack_uplo)[0];
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (3th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (3th argument) must be %d", 2);
-  lda = NA_SHAPE0(rblapack_a);
-  n = NA_SHAPE1(rblapack_a);
-  if (NA_TYPE(rblapack_a) != NA_SCOMPLEX)
-    rblapack_a = na_change_type(rblapack_a, NA_SCOMPLEX);
-  a = NA_PTR_TYPE(rblapack_a, complex*);
-  way = StringValueCStr(rblapack_way)[0];
-  if (!NA_IsNArray(rblapack_ipiv))
-    rb_raise(rb_eArgError, "ipiv (4th argument) must be NArray");
-  if (NA_RANK(rblapack_ipiv) != 1)
-    rb_raise(rb_eArgError, "rank of ipiv (4th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_ipiv) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of ipiv must be the same as shape 1 of a");
-  if (NA_TYPE(rblapack_ipiv) != NA_LINT)
-    rblapack_ipiv = na_change_type(rblapack_ipiv, NA_LINT);
-  ipiv = NA_PTR_TYPE(rblapack_ipiv, integer*);
-  work = ALLOC_N(complex, (MAX(1,n)));
-
-  csyconv_(&uplo, &way, &n, a, &lda, ipiv, work, &info);
-
-  free(work);
-  rblapack_info = INT2NUM(info);
-  return rblapack_info;
-}
-
-void
-init_lapack_csyconv(VALUE mLapack, VALUE sH, VALUE sU, VALUE zero){
-  sHelp = sH;
-  sUsage = sU;
-  rblapack_ZERO = zero;
-
-  rb_define_module_function(mLapack, "csyconv", rblapack_csyconv, -1);
-}