ruby-lapack 1.4.1a → 1.5

data/ext/zgtsv.c

@@ -53,6 +53,14 @@ rblapack_zgtsv(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  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);
+  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 (4th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
@@ -62,14 +70,6 @@ rblapack_zgtsv(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_b) != NA_DCOMPLEX)
     rblapack_b = na_change_type(rblapack_b, NA_DCOMPLEX);
   b = NA_PTR_TYPE(rblapack_b, doublecomplex*);
-  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);
-  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_dl))
     rb_raise(rb_eArgError, "dl (1th argument) must be NArray");
   if (NA_RANK(rblapack_dl) != 1)

data/ext/zgtsvx.c

@@ -87,62 +87,35 @@ rblapack_zgtsvx(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  if (!NA_IsNArray(rblapack_ipiv))
-    rb_raise(rb_eArgError, "ipiv (10th argument) must be NArray");
-  if (NA_RANK(rblapack_ipiv) != 1)
-    rb_raise(rb_eArgError, "rank of ipiv (10th 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_b))
-    rb_raise(rb_eArgError, "b (11th argument) must be NArray");
-  if (NA_RANK(rblapack_b) != 2)
-    rb_raise(rb_eArgError, "rank of b (11th argument) must be %d", 2);
-  ldb = NA_SHAPE0(rblapack_b);
-  nrhs = 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*);
   fact = StringValueCStr(rblapack_fact)[0];
-  trans = StringValueCStr(rblapack_trans)[0];
+  if (!NA_IsNArray(rblapack_d))
+    rb_raise(rb_eArgError, "d (4th argument) must be NArray");
+  if (NA_RANK(rblapack_d) != 1)
+    rb_raise(rb_eArgError, "rank of d (4th argument) must be %d", 1);
+  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_df))
     rb_raise(rb_eArgError, "df (7th argument) must be NArray");
   if (NA_RANK(rblapack_df) != 1)
     rb_raise(rb_eArgError, "rank of df (7th argument) must be %d", 1);
   if (NA_SHAPE0(rblapack_df) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of df must be the same as shape 0 of ipiv");
+    rb_raise(rb_eRuntimeError, "shape 0 of df must be the same as shape 0 of d");
   if (NA_TYPE(rblapack_df) != NA_DCOMPLEX)
     rblapack_df = na_change_type(rblapack_df, NA_DCOMPLEX);
   df = NA_PTR_TYPE(rblapack_df, doublecomplex*);
-  if (!NA_IsNArray(rblapack_d))
-    rb_raise(rb_eArgError, "d (4th argument) must be NArray");
-  if (NA_RANK(rblapack_d) != 1)
-    rb_raise(rb_eArgError, "rank of d (4th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_d) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of d must be the same as shape 0 of ipiv");
-  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_dlf))
-    rb_raise(rb_eArgError, "dlf (6th argument) must be NArray");
-  if (NA_RANK(rblapack_dlf) != 1)
-    rb_raise(rb_eArgError, "rank of dlf (6th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_dlf) != (n-1))
-    rb_raise(rb_eRuntimeError, "shape 0 of dlf must be %d", n-1);
-  if (NA_TYPE(rblapack_dlf) != NA_DCOMPLEX)
-    rblapack_dlf = na_change_type(rblapack_dlf, NA_DCOMPLEX);
-  dlf = NA_PTR_TYPE(rblapack_dlf, doublecomplex*);
-  if (!NA_IsNArray(rblapack_duf))
-    rb_raise(rb_eArgError, "duf (8th argument) must be NArray");
-  if (NA_RANK(rblapack_duf) != 1)
-    rb_raise(rb_eArgError, "rank of duf (8th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_duf) != (n-1))
-    rb_raise(rb_eRuntimeError, "shape 0 of duf must be %d", n-1);
-  if (NA_TYPE(rblapack_duf) != NA_DCOMPLEX)
-    rblapack_duf = na_change_type(rblapack_duf, NA_DCOMPLEX);
-  duf = NA_PTR_TYPE(rblapack_duf, doublecomplex*);
+  if (!NA_IsNArray(rblapack_ipiv))
+    rb_raise(rb_eArgError, "ipiv (10th argument) must be NArray");
+  if (NA_RANK(rblapack_ipiv) != 1)
+    rb_raise(rb_eArgError, "rank of ipiv (10th 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 0 of d");
+  if (NA_TYPE(rblapack_ipiv) != NA_LINT)
+    rblapack_ipiv = na_change_type(rblapack_ipiv, NA_LINT);
+  ipiv = NA_PTR_TYPE(rblapack_ipiv, integer*);
   ldx = MAX(1,n);
+  trans = StringValueCStr(rblapack_trans)[0];
   if (!NA_IsNArray(rblapack_du))
     rb_raise(rb_eArgError, "du (5th argument) must be NArray");
   if (NA_RANK(rblapack_du) != 1)
@@ -152,15 +125,24 @@ rblapack_zgtsvx(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_du) != NA_DCOMPLEX)
     rblapack_du = na_change_type(rblapack_du, NA_DCOMPLEX);
   du = NA_PTR_TYPE(rblapack_du, doublecomplex*);
-  if (!NA_IsNArray(rblapack_du2))
-    rb_raise(rb_eArgError, "du2 (9th argument) must be NArray");
-  if (NA_RANK(rblapack_du2) != 1)
-    rb_raise(rb_eArgError, "rank of du2 (9th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_du2) != (n-2))
-    rb_raise(rb_eRuntimeError, "shape 0 of du2 must be %d", n-2);
-  if (NA_TYPE(rblapack_du2) != NA_DCOMPLEX)
-    rblapack_du2 = na_change_type(rblapack_du2, NA_DCOMPLEX);
-  du2 = NA_PTR_TYPE(rblapack_du2, doublecomplex*);
+  if (!NA_IsNArray(rblapack_duf))
+    rb_raise(rb_eArgError, "duf (8th argument) must be NArray");
+  if (NA_RANK(rblapack_duf) != 1)
+    rb_raise(rb_eArgError, "rank of duf (8th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_duf) != (n-1))
+    rb_raise(rb_eRuntimeError, "shape 0 of duf must be %d", n-1);
+  if (NA_TYPE(rblapack_duf) != NA_DCOMPLEX)
+    rblapack_duf = na_change_type(rblapack_duf, NA_DCOMPLEX);
+  duf = NA_PTR_TYPE(rblapack_duf, doublecomplex*);
+  if (!NA_IsNArray(rblapack_b))
+    rb_raise(rb_eArgError, "b (11th argument) must be NArray");
+  if (NA_RANK(rblapack_b) != 2)
+    rb_raise(rb_eArgError, "rank of b (11th argument) must be %d", 2);
+  ldb = NA_SHAPE0(rblapack_b);
+  nrhs = 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 (!NA_IsNArray(rblapack_dl))
     rb_raise(rb_eArgError, "dl (3th argument) must be NArray");
   if (NA_RANK(rblapack_dl) != 1)
@@ -170,6 +152,24 @@ rblapack_zgtsvx(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_dl) != NA_DCOMPLEX)
     rblapack_dl = na_change_type(rblapack_dl, NA_DCOMPLEX);
   dl = NA_PTR_TYPE(rblapack_dl, doublecomplex*);
+  if (!NA_IsNArray(rblapack_du2))
+    rb_raise(rb_eArgError, "du2 (9th argument) must be NArray");
+  if (NA_RANK(rblapack_du2) != 1)
+    rb_raise(rb_eArgError, "rank of du2 (9th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_du2) != (n-2))
+    rb_raise(rb_eRuntimeError, "shape 0 of du2 must be %d", n-2);
+  if (NA_TYPE(rblapack_du2) != NA_DCOMPLEX)
+    rblapack_du2 = na_change_type(rblapack_du2, NA_DCOMPLEX);
+  du2 = NA_PTR_TYPE(rblapack_du2, doublecomplex*);
+  if (!NA_IsNArray(rblapack_dlf))
+    rb_raise(rb_eArgError, "dlf (6th argument) must be NArray");
+  if (NA_RANK(rblapack_dlf) != 1)
+    rb_raise(rb_eArgError, "rank of dlf (6th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_dlf) != (n-1))
+    rb_raise(rb_eRuntimeError, "shape 0 of dlf must be %d", n-1);
+  if (NA_TYPE(rblapack_dlf) != NA_DCOMPLEX)
+    rblapack_dlf = na_change_type(rblapack_dlf, NA_DCOMPLEX);
+  dlf = NA_PTR_TYPE(rblapack_dlf, doublecomplex*);
   {
     int shape[2];
     shape[0] = ldx;

data/ext/zgttrs.c

@@ -56,33 +56,24 @@ rblapack_zgttrs(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  if (!NA_IsNArray(rblapack_ipiv))
-    rb_raise(rb_eArgError, "ipiv (6th argument) must be NArray");
-  if (NA_RANK(rblapack_ipiv) != 1)
-    rb_raise(rb_eArgError, "rank of ipiv (6th 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_b))
-    rb_raise(rb_eArgError, "b (7th argument) must be NArray");
-  if (NA_RANK(rblapack_b) != 2)
-    rb_raise(rb_eArgError, "rank of b (7th argument) must be %d", 2);
-  ldb = NA_SHAPE0(rblapack_b);
-  nrhs = 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*);
   trans = StringValueCStr(rblapack_trans)[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);
-  if (NA_SHAPE0(rblapack_d) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of d must be the same as shape 0 of ipiv");
+  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_ipiv))
+    rb_raise(rb_eArgError, "ipiv (6th argument) must be NArray");
+  if (NA_RANK(rblapack_ipiv) != 1)
+    rb_raise(rb_eArgError, "rank of ipiv (6th 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 0 of d");
+  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_dl))
     rb_raise(rb_eArgError, "dl (2th argument) must be NArray");
   if (NA_RANK(rblapack_dl) != 1)
@@ -110,6 +101,15 @@ rblapack_zgttrs(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_du) != NA_DCOMPLEX)
     rblapack_du = na_change_type(rblapack_du, NA_DCOMPLEX);
   du = NA_PTR_TYPE(rblapack_du, doublecomplex*);
+  if (!NA_IsNArray(rblapack_b))
+    rb_raise(rb_eArgError, "b (7th argument) must be NArray");
+  if (NA_RANK(rblapack_b) != 2)
+    rb_raise(rb_eArgError, "rank of b (7th argument) must be %d", 2);
+  ldb = NA_SHAPE0(rblapack_b);
+  nrhs = 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*);
   {
     int shape[2];
     shape[0] = ldb;

data/ext/zgtts2.c

@@ -54,32 +54,24 @@ rblapack_zgtts2(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  if (!NA_IsNArray(rblapack_ipiv))
-    rb_raise(rb_eArgError, "ipiv (6th argument) must be NArray");
-  if (NA_RANK(rblapack_ipiv) != 1)
-    rb_raise(rb_eArgError, "rank of ipiv (6th 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_b))
-    rb_raise(rb_eArgError, "b (7th argument) must be NArray");
-  if (NA_RANK(rblapack_b) != 2)
-    rb_raise(rb_eArgError, "rank of b (7th argument) must be %d", 2);
-  ldb = NA_SHAPE0(rblapack_b);
-  nrhs = 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*);
+  itrans = NUM2INT(rblapack_itrans);
   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);
-  if (NA_SHAPE0(rblapack_d) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of d must be the same as shape 0 of ipiv");
+  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_ipiv))
+    rb_raise(rb_eArgError, "ipiv (6th argument) must be NArray");
+  if (NA_RANK(rblapack_ipiv) != 1)
+    rb_raise(rb_eArgError, "rank of ipiv (6th 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 0 of d");
+  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_dl))
     rb_raise(rb_eArgError, "dl (2th argument) must be NArray");
   if (NA_RANK(rblapack_dl) != 1)
@@ -107,7 +99,15 @@ rblapack_zgtts2(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_du) != NA_DCOMPLEX)
     rblapack_du = na_change_type(rblapack_du, NA_DCOMPLEX);
   du = NA_PTR_TYPE(rblapack_du, doublecomplex*);
-  itrans = NUM2INT(rblapack_itrans);
+  if (!NA_IsNArray(rblapack_b))
+    rb_raise(rb_eArgError, "b (7th argument) must be NArray");
+  if (NA_RANK(rblapack_b) != 2)
+    rb_raise(rb_eArgError, "rank of b (7th argument) must be %d", 2);
+  ldb = NA_SHAPE0(rblapack_b);
+  nrhs = 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*);
   {
     int shape[2];
     shape[0] = ldb;

data/ext/zhbev.c

@@ -53,6 +53,9 @@ rblapack_zhbev(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  jobz = StringValueCStr(rblapack_jobz)[0];
+  kd = NUM2INT(rblapack_kd);
+  uplo = StringValueCStr(rblapack_uplo)[0];
   if (!NA_IsNArray(rblapack_ab))
     rb_raise(rb_eArgError, "ab (4th argument) must be NArray");
   if (NA_RANK(rblapack_ab) != 2)
@@ -62,9 +65,6 @@ rblapack_zhbev(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_ab) != NA_DCOMPLEX)
     rblapack_ab = na_change_type(rblapack_ab, NA_DCOMPLEX);
   ab = NA_PTR_TYPE(rblapack_ab, doublecomplex*);
-  kd = NUM2INT(rblapack_kd);
-  uplo = StringValueCStr(rblapack_uplo)[0];
-  jobz = StringValueCStr(rblapack_jobz)[0];
   ldz = lsame_(&jobz,"V") ? MAX(1,n) : 1;
   {
     int shape[1];

data/ext/zhbevd.c

@@ -72,6 +72,9 @@ rblapack_zhbevd(int argc, VALUE *argv, VALUE self){
     rblapack_liwork = Qnil;
   }
 
+  jobz = StringValueCStr(rblapack_jobz)[0];
+  kd = NUM2INT(rblapack_kd);
+  uplo = StringValueCStr(rblapack_uplo)[0];
   if (!NA_IsNArray(rblapack_ab))
     rb_raise(rb_eArgError, "ab (4th argument) must be NArray");
   if (NA_RANK(rblapack_ab) != 2)
@@ -81,25 +84,22 @@ rblapack_zhbevd(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_ab) != NA_DCOMPLEX)
     rblapack_ab = na_change_type(rblapack_ab, NA_DCOMPLEX);
   ab = NA_PTR_TYPE(rblapack_ab, doublecomplex*);
-  kd = NUM2INT(rblapack_kd);
-  jobz = StringValueCStr(rblapack_jobz)[0];
-  ldz = lsame_(&jobz,"V") ? MAX(1,n) : 1;
   if (rblapack_lrwork == Qnil)
     lrwork = n<=1 ? 1 : lsame_(&jobz,"N") ? n : lsame_(&jobz,"V") ? 1+5*n+2*n*n : 0;
   else {
     lrwork = NUM2INT(rblapack_lrwork);
   }
-  uplo = StringValueCStr(rblapack_uplo)[0];
-  if (rblapack_liwork == Qnil)
-    liwork = n<=1 ? 1 : lsame_(&jobz,"N") ? 1 : lsame_(&jobz,"V") ? 3+5*n : 0;
-  else {
-    liwork = NUM2INT(rblapack_liwork);
-  }
+  ldz = lsame_(&jobz,"V") ? MAX(1,n) : 1;
   if (rblapack_lwork == Qnil)
     lwork = n<=1 ? 1 : lsame_(&jobz,"N") ? n : lsame_(&jobz,"V") ? 2*n*n : 0;
   else {
     lwork = NUM2INT(rblapack_lwork);
   }
+  if (rblapack_liwork == Qnil)
+    liwork = n<=1 ? 1 : lsame_(&jobz,"N") ? 1 : lsame_(&jobz,"V") ? 3+5*n : 0;
+  else {
+    liwork = NUM2INT(rblapack_liwork);
+  }
   {
     int shape[1];
     shape[0] = n;

data/ext/zhbevx.c

@@ -79,13 +79,7 @@ rblapack_zhbevx(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  abstol = NUM2DBL(rblapack_abstol);
-  iu = NUM2INT(rblapack_iu);
-  il = NUM2INT(rblapack_il);
-  range = StringValueCStr(rblapack_range)[0];
   jobz = StringValueCStr(rblapack_jobz)[0];
-  vl = NUM2DBL(rblapack_vl);
-  kd = NUM2INT(rblapack_kd);
   uplo = StringValueCStr(rblapack_uplo)[0];
   if (!NA_IsNArray(rblapack_ab))
     rb_raise(rb_eArgError, "ab (5th argument) must be NArray");
@@ -96,10 +90,16 @@ rblapack_zhbevx(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_ab) != NA_DCOMPLEX)
     rblapack_ab = na_change_type(rblapack_ab, NA_DCOMPLEX);
   ab = NA_PTR_TYPE(rblapack_ab, doublecomplex*);
-  m = lsame_(&range,"A") ? n : lsame_(&range,"I") ? iu-il+1 : 0;
   vu = NUM2DBL(rblapack_vu);
+  iu = NUM2INT(rblapack_iu);
   ldz = lsame_(&jobz,"V") ? MAX(1,n) : 1;
   ldq = lsame_(&jobz,"V") ? MAX(1,n) : 0;
+  range = StringValueCStr(rblapack_range)[0];
+  vl = NUM2DBL(rblapack_vl);
+  abstol = NUM2DBL(rblapack_abstol);
+  kd = NUM2INT(rblapack_kd);
+  il = NUM2INT(rblapack_il);
+  m = lsame_(&range,"A") ? n : lsame_(&range,"I") ? iu-il+1 : 0;
   {
     int shape[2];
     shape[0] = ldq;

data/ext/zhbgst.c

@@ -58,30 +58,30 @@ rblapack_zhbgst(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  if (!NA_IsNArray(rblapack_bb))
-    rb_raise(rb_eArgError, "bb (6th argument) must be NArray");
-  if (NA_RANK(rblapack_bb) != 2)
-    rb_raise(rb_eArgError, "rank of bb (6th argument) must be %d", 2);
-  ldbb = NA_SHAPE0(rblapack_bb);
-  n = NA_SHAPE1(rblapack_bb);
-  if (NA_TYPE(rblapack_bb) != NA_DCOMPLEX)
-    rblapack_bb = na_change_type(rblapack_bb, NA_DCOMPLEX);
-  bb = NA_PTR_TYPE(rblapack_bb, doublecomplex*);
+  vect = StringValueCStr(rblapack_vect)[0];
+  ka = NUM2INT(rblapack_ka);
   if (!NA_IsNArray(rblapack_ab))
     rb_raise(rb_eArgError, "ab (5th argument) must be NArray");
   if (NA_RANK(rblapack_ab) != 2)
     rb_raise(rb_eArgError, "rank of ab (5th argument) must be %d", 2);
   ldab = NA_SHAPE0(rblapack_ab);
-  if (NA_SHAPE1(rblapack_ab) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of ab must be the same as shape 1 of bb");
+  n = NA_SHAPE1(rblapack_ab);
   if (NA_TYPE(rblapack_ab) != NA_DCOMPLEX)
     rblapack_ab = na_change_type(rblapack_ab, NA_DCOMPLEX);
   ab = NA_PTR_TYPE(rblapack_ab, doublecomplex*);
-  vect = StringValueCStr(rblapack_vect)[0];
-  ldx = lsame_(&vect,"V") ? MAX(1,n) : 1;
-  kb = NUM2INT(rblapack_kb);
-  ka = NUM2INT(rblapack_ka);
   uplo = StringValueCStr(rblapack_uplo)[0];
+  if (!NA_IsNArray(rblapack_bb))
+    rb_raise(rb_eArgError, "bb (6th argument) must be NArray");
+  if (NA_RANK(rblapack_bb) != 2)
+    rb_raise(rb_eArgError, "rank of bb (6th argument) must be %d", 2);
+  ldbb = NA_SHAPE0(rblapack_bb);
+  if (NA_SHAPE1(rblapack_bb) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of bb must be the same as shape 1 of ab");
+  if (NA_TYPE(rblapack_bb) != NA_DCOMPLEX)
+    rblapack_bb = na_change_type(rblapack_bb, NA_DCOMPLEX);
+  bb = NA_PTR_TYPE(rblapack_bb, doublecomplex*);
+  kb = NUM2INT(rblapack_kb);
+  ldx = lsame_(&vect,"V") ? MAX(1,n) : 1;
   {
     int shape[2];
     shape[0] = ldx;

data/ext/zhbgv.c

@@ -62,30 +62,30 @@ rblapack_zhbgv(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  if (!NA_IsNArray(rblapack_bb))
-    rb_raise(rb_eArgError, "bb (6th argument) must be NArray");
-  if (NA_RANK(rblapack_bb) != 2)
-    rb_raise(rb_eArgError, "rank of bb (6th argument) must be %d", 2);
-  ldbb = NA_SHAPE0(rblapack_bb);
-  n = NA_SHAPE1(rblapack_bb);
-  if (NA_TYPE(rblapack_bb) != NA_DCOMPLEX)
-    rblapack_bb = na_change_type(rblapack_bb, NA_DCOMPLEX);
-  bb = NA_PTR_TYPE(rblapack_bb, doublecomplex*);
+  jobz = StringValueCStr(rblapack_jobz)[0];
+  ka = NUM2INT(rblapack_ka);
   if (!NA_IsNArray(rblapack_ab))
     rb_raise(rb_eArgError, "ab (5th argument) must be NArray");
   if (NA_RANK(rblapack_ab) != 2)
     rb_raise(rb_eArgError, "rank of ab (5th argument) must be %d", 2);
   ldab = NA_SHAPE0(rblapack_ab);
-  if (NA_SHAPE1(rblapack_ab) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of ab must be the same as shape 1 of bb");
+  n = NA_SHAPE1(rblapack_ab);
   if (NA_TYPE(rblapack_ab) != NA_DCOMPLEX)
     rblapack_ab = na_change_type(rblapack_ab, NA_DCOMPLEX);
   ab = NA_PTR_TYPE(rblapack_ab, doublecomplex*);
-  jobz = StringValueCStr(rblapack_jobz)[0];
-  ka = NUM2INT(rblapack_ka);
-  ldz = lsame_(&jobz,"V") ? n : 1;
-  kb = NUM2INT(rblapack_kb);
   uplo = StringValueCStr(rblapack_uplo)[0];
+  if (!NA_IsNArray(rblapack_bb))
+    rb_raise(rb_eArgError, "bb (6th argument) must be NArray");
+  if (NA_RANK(rblapack_bb) != 2)
+    rb_raise(rb_eArgError, "rank of bb (6th argument) must be %d", 2);
+  ldbb = NA_SHAPE0(rblapack_bb);
+  if (NA_SHAPE1(rblapack_bb) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of bb must be the same as shape 1 of ab");
+  if (NA_TYPE(rblapack_bb) != NA_DCOMPLEX)
+    rblapack_bb = na_change_type(rblapack_bb, NA_DCOMPLEX);
+  bb = NA_PTR_TYPE(rblapack_bb, doublecomplex*);
+  kb = NUM2INT(rblapack_kb);
+  ldz = lsame_(&jobz,"V") ? n : 1;
   {
     int shape[1];
     shape[0] = n;