ruby-lapack 1.4.1a → 1.5

data/ext/zggbal.c

@@ -55,26 +55,26 @@ rblapack_zggbal(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (2th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (2th argument) must be %d", 2);
-  lda = NA_SHAPE0(rblapack_a);
-  n = NA_SHAPE1(rblapack_a);
-  if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
-    rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
-  a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
   job = StringValueCStr(rblapack_job)[0];
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (3th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
     rb_raise(rb_eArgError, "rank of b (3th 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");
+  n = 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_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 1 of b");
+  if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
+    rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
+  a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
   {
     int shape[1];
     shape[0] = n;

data/ext/zgges.c

@@ -89,35 +89,35 @@ rblapack_zgges(int argc, VALUE *argv, VALUE self){
     rblapack_lwork = Qnil;
   }
 
-  if (!NA_IsNArray(rblapack_a))
-    rb_raise(rb_eArgError, "a (4th argument) must be NArray");
-  if (NA_RANK(rblapack_a) != 2)
-    rb_raise(rb_eArgError, "rank of a (4th 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*);
-  jobvsr = StringValueCStr(rblapack_jobvsr)[0];
+  jobvsl = StringValueCStr(rblapack_jobvsl)[0];
   sort = StringValueCStr(rblapack_sort)[0];
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (5th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
     rb_raise(rb_eArgError, "rank of b (5th 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");
+  n = 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*);
-  ldvsr = lsame_(&jobvsr,"V") ? n : 1;
+  jobvsr = StringValueCStr(rblapack_jobvsr)[0];
+  if (!NA_IsNArray(rblapack_a))
+    rb_raise(rb_eArgError, "a (4th argument) must be NArray");
+  if (NA_RANK(rblapack_a) != 2)
+    rb_raise(rb_eArgError, "rank of a (4th 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 1 of b");
+  if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
+    rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
+  a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
+  ldvsl = lsame_(&jobvsl,"V") ? n : 1;
   if (rblapack_lwork == Qnil)
     lwork = 2*n;
   else {
     lwork = NUM2INT(rblapack_lwork);
   }
-  jobvsl = StringValueCStr(rblapack_jobvsl)[0];
-  ldvsl = lsame_(&jobvsl,"V") ? n : 1;
+  ldvsr = lsame_(&jobvsr,"V") ? n : 1;
   {
     int shape[1];
     shape[0] = n;

data/ext/zggesx.c

@@ -103,6 +103,8 @@ rblapack_zggesx(int argc, VALUE *argv, VALUE self){
     rblapack_liwork = Qnil;
   }
 
+  jobvsl = StringValueCStr(rblapack_jobvsl)[0];
+  sort = StringValueCStr(rblapack_sort)[0];
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (5th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -112,8 +114,7 @@ rblapack_zggesx(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
-  sense = StringValueCStr(rblapack_sense)[0];
-  sort = StringValueCStr(rblapack_sort)[0];
+  jobvsr = StringValueCStr(rblapack_jobvsr)[0];
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (6th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
@@ -124,20 +125,19 @@ rblapack_zggesx(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*);
-  jobvsr = StringValueCStr(rblapack_jobvsr)[0];
-  ldvsr = lsame_(&jobvsr,"V") ? n : 1;
+  ldvsl = lsame_(&jobvsl,"V") ? n : 1;
+  sense = StringValueCStr(rblapack_sense)[0];
   if (rblapack_liwork == Qnil)
     liwork = (lsame_(&sense,"N")||n==0) ? 1 : n+2;
   else {
     liwork = NUM2INT(rblapack_liwork);
   }
-  jobvsl = StringValueCStr(rblapack_jobvsl)[0];
-  ldvsl = lsame_(&jobvsl,"V") ? n : 1;
   if (rblapack_lwork == Qnil)
     lwork = n==0 ? 1 : (lsame_(&sense,"E")||lsame_(&sense,"V")||lsame_(&sense,"B")) ? MAX(2*n,n*n/2) : 2*n;
   else {
     lwork = NUM2INT(rblapack_lwork);
   }
+  ldvsr = lsame_(&jobvsr,"V") ? n : 1;
   {
     int shape[1];
     shape[0] = n;

data/ext/zggev.c

@@ -68,6 +68,7 @@ rblapack_zggev(int argc, VALUE *argv, VALUE self){
     rblapack_lwork = Qnil;
   }
 
+  jobvl = StringValueCStr(rblapack_jobvl)[0];
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (3th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -77,6 +78,7 @@ rblapack_zggev(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
+  jobvr = StringValueCStr(rblapack_jobvr)[0];
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (4th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
@@ -87,14 +89,12 @@ rblapack_zggev(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*);
-  jobvl = StringValueCStr(rblapack_jobvl)[0];
-  jobvr = StringValueCStr(rblapack_jobvr)[0];
+  ldvr = lsame_(&jobvr,"V") ? n : 1;
   if (rblapack_lwork == Qnil)
     lwork = MAX(1,2*n);
   else {
     lwork = NUM2INT(rblapack_lwork);
   }
-  ldvr = lsame_(&jobvr,"V") ? n : 1;
   ldvl = lsame_(&jobvl,"V") ? n : 1;
   {
     int shape[1];

data/ext/zggevx.c

@@ -92,6 +92,8 @@ rblapack_zggevx(int argc, VALUE *argv, VALUE self){
     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)
@@ -101,6 +103,7 @@ rblapack_zggevx(int argc, VALUE *argv, VALUE self){
   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)
@@ -111,13 +114,10 @@ rblapack_zggevx(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*);
+  ldvr = lsame_(&jobvr,"V") ? n : 1;
+  ldvl = lsame_(&jobvl,"V") ? n : 1;
   sense = StringValueCStr(rblapack_sense)[0];
-  jobvl = StringValueCStr(rblapack_jobvl)[0];
-  balanc = StringValueCStr(rblapack_balanc)[0];
-  jobvr = StringValueCStr(rblapack_jobvr)[0];
   lrwork = ((lsame_(&balanc,"S")) || (lsame_(&balanc,"B"))) ? MAX(1,6*n) : MAX(1,2*n);
-  ldvl = lsame_(&jobvl,"V") ? n : 1;
-  ldvr = lsame_(&jobvr,"V") ? n : 1;
   if (rblapack_lwork == Qnil)
     lwork = lsame_(&sense,"E") ? 4*n : (lsame_(&sense,"V")||lsame_(&sense,"B")) ? 2*n*n+2*n : 2*n;
   else {

data/ext/zgghrd.c

@@ -67,6 +67,8 @@ rblapack_zgghrd(int argc, VALUE *argv, VALUE self){
   } 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)
@@ -76,6 +78,17 @@ rblapack_zgghrd(int argc, VALUE *argv, VALUE self){
   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)
@@ -86,6 +99,7 @@ rblapack_zgghrd(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*);
+  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)
@@ -96,20 +110,6 @@ rblapack_zgghrd(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_z) != NA_DCOMPLEX)
     rblapack_z = na_change_type(rblapack_z, NA_DCOMPLEX);
   z = NA_PTR_TYPE(rblapack_z, 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*);
-  ilo = NUM2INT(rblapack_ilo);
-  compq = StringValueCStr(rblapack_compq)[0];
-  compz = StringValueCStr(rblapack_compz)[0];
-  ihi = NUM2INT(rblapack_ihi);
   {
     int shape[2];
     shape[0] = lda;

data/ext/zggqrf.c

@@ -58,15 +58,6 @@ rblapack_zggqrf(int argc, VALUE *argv, VALUE self){
     rblapack_lwork = Qnil;
   }
 
-  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);
-  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*);
   n = NUM2INT(rblapack_n);
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (3th argument) must be NArray");
@@ -77,6 +68,15 @@ rblapack_zggqrf(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_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);
+  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 (rblapack_lwork == Qnil)
     lwork = MAX(MAX(n,m),p);
   else {

data/ext/zggrqf.c

@@ -60,6 +60,7 @@ rblapack_zggrqf(int argc, VALUE *argv, VALUE self){
     rblapack_lwork = Qnil;
   }
 
+  m = NUM2INT(rblapack_m);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (3th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -69,7 +70,6 @@ rblapack_zggrqf(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_a) != NA_DCOMPLEX)
     rblapack_a = na_change_type(rblapack_a, NA_DCOMPLEX);
   a = NA_PTR_TYPE(rblapack_a, doublecomplex*);
-  m = NUM2INT(rblapack_m);
   p = NUM2INT(rblapack_p);
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (4th argument) must be NArray");

data/ext/zggsvd.c

@@ -75,6 +75,7 @@ rblapack_zggsvd(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  jobu = StringValueCStr(rblapack_jobu)[0];
   jobq = StringValueCStr(rblapack_jobq)[0];
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (5th argument) must be NArray");
@@ -85,8 +86,9 @@ rblapack_zggsvd(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*);
-  jobu = StringValueCStr(rblapack_jobu)[0];
+  p = ldb;
   jobv = StringValueCStr(rblapack_jobv)[0];
+  ldv = lsame_(&jobv,"V") ? MAX(1,p) : 1;
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (4th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -100,8 +102,6 @@ rblapack_zggsvd(int argc, VALUE *argv, VALUE self){
   ldq = lsame_(&jobq,"Q") ? MAX(1,n) : 1;
   m = lda;
   ldu = lsame_(&jobu,"U") ? MAX(1,m) : 1;
-  p = ldb;
-  ldv = lsame_(&jobv,"V") ? MAX(1,p) : 1;
   {
     int shape[1];
     shape[0] = n;

data/ext/zggsvp.c

@@ -77,6 +77,7 @@ rblapack_zggsvp(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  jobu = StringValueCStr(rblapack_jobu)[0];
   jobq = StringValueCStr(rblapack_jobq)[0];
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (5th argument) must be NArray");
@@ -87,10 +88,11 @@ rblapack_zggsvp(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*);
-  jobu = StringValueCStr(rblapack_jobu)[0];
+  tolb = NUM2DBL(rblapack_tolb);
+  p = ldb;
   jobv = StringValueCStr(rblapack_jobv)[0];
   tola = NUM2DBL(rblapack_tola);
-  tolb = NUM2DBL(rblapack_tolb);
+  ldv = lsame_(&jobv,"V") ? MAX(1,p) : 1;
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (4th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -104,8 +106,6 @@ rblapack_zggsvp(int argc, VALUE *argv, VALUE self){
   ldq = lsame_(&jobq,"Q") ? MAX(1,n) : 1;
   m = lda;
   ldu = lsame_(&jobu,"U") ? MAX(1,m) : 1;
-  p = ldb;
-  ldv = lsame_(&jobv,"V") ? MAX(1,p) : 1;
   {
     int shape[2];
     shape[0] = ldu;

data/ext/zgtcon.c

@@ -55,7 +55,7 @@ rblapack_zgtcon(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  anorm = NUM2DBL(rblapack_anorm);
+  norm = StringValueCStr(rblapack_norm)[0];
   if (!NA_IsNArray(rblapack_d))
     rb_raise(rb_eArgError, "d (3th argument) must be NArray");
   if (NA_RANK(rblapack_d) != 1)
@@ -64,7 +64,6 @@ rblapack_zgtcon(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_d) != NA_DCOMPLEX)
     rblapack_d = na_change_type(rblapack_d, NA_DCOMPLEX);
   d = NA_PTR_TYPE(rblapack_d, doublecomplex*);
-  norm = StringValueCStr(rblapack_norm)[0];
   if (!NA_IsNArray(rblapack_ipiv))
     rb_raise(rb_eArgError, "ipiv (6th argument) must be NArray");
   if (NA_RANK(rblapack_ipiv) != 1)
@@ -74,24 +73,6 @@ rblapack_zgtcon(int argc, VALUE *argv, VALUE self){
   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_du))
-    rb_raise(rb_eArgError, "du (4th argument) must be NArray");
-  if (NA_RANK(rblapack_du) != 1)
-    rb_raise(rb_eArgError, "rank of du (4th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_du) != (n-1))
-    rb_raise(rb_eRuntimeError, "shape 0 of du must be %d", n-1);
-  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 (5th argument) must be NArray");
-  if (NA_RANK(rblapack_du2) != 1)
-    rb_raise(rb_eArgError, "rank of du2 (5th 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_dl))
     rb_raise(rb_eArgError, "dl (2th argument) must be NArray");
   if (NA_RANK(rblapack_dl) != 1)
@@ -101,6 +82,25 @@ rblapack_zgtcon(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 (5th argument) must be NArray");
+  if (NA_RANK(rblapack_du2) != 1)
+    rb_raise(rb_eArgError, "rank of du2 (5th 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_du))
+    rb_raise(rb_eArgError, "du (4th argument) must be NArray");
+  if (NA_RANK(rblapack_du) != 1)
+    rb_raise(rb_eArgError, "rank of du (4th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_du) != (n-1))
+    rb_raise(rb_eRuntimeError, "shape 0 of du must be %d", n-1);
+  if (NA_TYPE(rblapack_du) != NA_DCOMPLEX)
+    rblapack_du = na_change_type(rblapack_du, NA_DCOMPLEX);
+  du = NA_PTR_TYPE(rblapack_du, doublecomplex*);
+  anorm = NUM2DBL(rblapack_anorm);
   work = ALLOC_N(doublecomplex, (2*n));
 
   zgtcon_(&norm, &n, dl, d, du, du2, ipiv, &anorm, &rcond, work, &info);

data/ext/zgtrfs.c

@@ -75,11 +75,30 @@ rblapack_zgtrfs(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  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);
+  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 (6th argument) must be NArray");
+  if (NA_RANK(rblapack_df) != 1)
+    rb_raise(rb_eArgError, "rank of df (6th 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 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_ipiv))
     rb_raise(rb_eArgError, "ipiv (9th argument) must be NArray");
   if (NA_RANK(rblapack_ipiv) != 1)
     rb_raise(rb_eArgError, "rank of ipiv (9th argument) must be %d", 1);
-  n = NA_SHAPE0(rblapack_ipiv);
+  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*);
@@ -92,35 +111,15 @@ rblapack_zgtrfs(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_x) != NA_DCOMPLEX)
     rblapack_x = na_change_type(rblapack_x, NA_DCOMPLEX);
   x = NA_PTR_TYPE(rblapack_x, doublecomplex*);
-  if (!NA_IsNArray(rblapack_df))
-    rb_raise(rb_eArgError, "df (6th argument) must be NArray");
-  if (NA_RANK(rblapack_df) != 1)
-    rb_raise(rb_eArgError, "rank of df (6th 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");
-  if (NA_TYPE(rblapack_df) != NA_DCOMPLEX)
-    rblapack_df = na_change_type(rblapack_df, NA_DCOMPLEX);
-  df = NA_PTR_TYPE(rblapack_df, doublecomplex*);
-  trans = StringValueCStr(rblapack_trans)[0];
-  if (!NA_IsNArray(rblapack_b))
-    rb_raise(rb_eArgError, "b (10th argument) must be NArray");
-  if (NA_RANK(rblapack_b) != 2)
-    rb_raise(rb_eArgError, "rank of b (10th argument) must be %d", 2);
-  ldb = NA_SHAPE0(rblapack_b);
-  if (NA_SHAPE1(rblapack_b) != nrhs)
-    rb_raise(rb_eRuntimeError, "shape 1 of b must be the same as shape 1 of x");
-  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 (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");
-  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 (2th argument) must be NArray");
+  if (NA_RANK(rblapack_dl) != 1)
+    rb_raise(rb_eArgError, "rank of dl (2th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_dl) != (n-1))
+    rb_raise(rb_eRuntimeError, "shape 0 of dl must be %d", n-1);
+  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_dlf))
     rb_raise(rb_eArgError, "dlf (5th argument) must be NArray");
   if (NA_RANK(rblapack_dlf) != 1)
@@ -130,15 +129,6 @@ rblapack_zgtrfs(int argc, VALUE *argv, VALUE self){
   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 (7th argument) must be NArray");
-  if (NA_RANK(rblapack_duf) != 1)
-    rb_raise(rb_eArgError, "rank of duf (7th 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_du2))
     rb_raise(rb_eArgError, "du2 (8th argument) must be NArray");
   if (NA_RANK(rblapack_du2) != 1)
@@ -148,15 +138,6 @@ rblapack_zgtrfs(int argc, VALUE *argv, VALUE self){
   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_dl))
-    rb_raise(rb_eArgError, "dl (2th argument) must be NArray");
-  if (NA_RANK(rblapack_dl) != 1)
-    rb_raise(rb_eArgError, "rank of dl (2th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_dl) != (n-1))
-    rb_raise(rb_eRuntimeError, "shape 0 of dl must be %d", n-1);
-  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_du))
     rb_raise(rb_eArgError, "du (4th argument) must be NArray");
   if (NA_RANK(rblapack_du) != 1)
@@ -166,6 +147,25 @@ rblapack_zgtrfs(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 (10th argument) must be NArray");
+  if (NA_RANK(rblapack_b) != 2)
+    rb_raise(rb_eArgError, "rank of b (10th argument) must be %d", 2);
+  ldb = NA_SHAPE0(rblapack_b);
+  if (NA_SHAPE1(rblapack_b) != nrhs)
+    rb_raise(rb_eRuntimeError, "shape 1 of b must be the same as shape 1 of x");
+  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_duf))
+    rb_raise(rb_eArgError, "duf (7th argument) must be NArray");
+  if (NA_RANK(rblapack_duf) != 1)
+    rb_raise(rb_eArgError, "rank of duf (7th 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*);
   {
     int shape[1];
     shape[0] = nrhs;