ruby-lapack 1.4.1a → 1.5

data/ext/ztbtrs.c

@@ -54,6 +54,8 @@ rblapack_ztbtrs(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  uplo = StringValueCStr(rblapack_uplo)[0];
+  diag = StringValueCStr(rblapack_diag)[0];
   if (!NA_IsNArray(rblapack_ab))
     rb_raise(rb_eArgError, "ab (5th argument) must be NArray");
   if (NA_RANK(rblapack_ab) != 2)
@@ -63,7 +65,6 @@ rblapack_ztbtrs(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*);
-  diag = StringValueCStr(rblapack_diag)[0];
   trans = StringValueCStr(rblapack_trans)[0];
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (6th argument) must be NArray");
@@ -74,7 +75,6 @@ rblapack_ztbtrs(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*);
-  uplo = StringValueCStr(rblapack_uplo)[0];
   kd = NUM2INT(rblapack_kd);
   {
     int shape[2];

data/ext/ztfsm.c

@@ -59,11 +59,11 @@ rblapack_ztfsm(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  side = StringValueCStr(rblapack_side)[0];
-  m = NUM2INT(rblapack_m);
+  transr = StringValueCStr(rblapack_transr)[0];
+  uplo = StringValueCStr(rblapack_uplo)[0];
+  diag = StringValueCStr(rblapack_diag)[0];
   alpha.r = NUM2DBL(rb_funcall(rblapack_alpha, rb_intern("real"), 0));
   alpha.i = NUM2DBL(rb_funcall(rblapack_alpha, rb_intern("imag"), 0));
-  uplo = StringValueCStr(rblapack_uplo)[0];
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (9th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
@@ -73,6 +73,8 @@ rblapack_ztfsm(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*);
+  side = StringValueCStr(rblapack_side)[0];
+  m = NUM2INT(rblapack_m);
   trans = StringValueCStr(rblapack_trans)[0];
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (8th argument) must be NArray");
@@ -83,8 +85,6 @@ rblapack_ztfsm(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*);
-  transr = StringValueCStr(rblapack_transr)[0];
-  diag = StringValueCStr(rblapack_diag)[0];
   {
     int shape[2];
     shape[0] = ldb;

data/ext/ztftri.c

@@ -47,6 +47,7 @@ rblapack_ztftri(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  transr = StringValueCStr(rblapack_transr)[0];
   diag = StringValueCStr(rblapack_diag)[0];
   uplo = StringValueCStr(rblapack_uplo)[0];
   n = NUM2INT(rblapack_n);
@@ -59,7 +60,6 @@ rblapack_ztftri(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*);
-  transr = StringValueCStr(rblapack_transr)[0];
   {
     int shape[1];
     shape[0] = n*(n+1)/2;

data/ext/ztfttp.c

@@ -44,6 +44,7 @@ rblapack_ztfttp(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  transr = StringValueCStr(rblapack_transr)[0];
   n = NUM2INT(rblapack_n);
   uplo = StringValueCStr(rblapack_uplo)[0];
   if (!NA_IsNArray(rblapack_arf))
@@ -55,7 +56,6 @@ rblapack_ztfttp(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_arf) != NA_DCOMPLEX)
     rblapack_arf = na_change_type(rblapack_arf, NA_DCOMPLEX);
   arf = NA_PTR_TYPE(rblapack_arf, doublecomplex*);
-  transr = StringValueCStr(rblapack_transr)[0];
   {
     int shape[1];
     shape[0] = ( n*(n+1)/2 );

data/ext/ztfttr.c

@@ -44,6 +44,7 @@ rblapack_ztfttr(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  transr = StringValueCStr(rblapack_transr)[0];
   if (!NA_IsNArray(rblapack_arf))
     rb_raise(rb_eArgError, "arf (3th argument) must be NArray");
   if (NA_RANK(rblapack_arf) != 1)
@@ -52,7 +53,6 @@ rblapack_ztfttr(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_arf) != NA_DCOMPLEX)
     rblapack_arf = na_change_type(rblapack_arf, NA_DCOMPLEX);
   arf = NA_PTR_TYPE(rblapack_arf, doublecomplex*);
-  transr = StringValueCStr(rblapack_transr)[0];
   n = ((int)sqrtf(8*ldarf+1.0f)-1)/2;
   uplo = StringValueCStr(rblapack_uplo)[0];
   lda = MAX(1,n);

data/ext/ztgevc.c

@@ -65,55 +65,55 @@ rblapack_ztgevc(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  if (!NA_IsNArray(rblapack_vl))
-    rb_raise(rb_eArgError, "vl (6th argument) must be NArray");
-  if (NA_RANK(rblapack_vl) != 2)
-    rb_raise(rb_eArgError, "rank of vl (6th argument) must be %d", 2);
-  ldvl = NA_SHAPE0(rblapack_vl);
-  mm = NA_SHAPE1(rblapack_vl);
-  if (NA_TYPE(rblapack_vl) != NA_DCOMPLEX)
-    rblapack_vl = na_change_type(rblapack_vl, NA_DCOMPLEX);
-  vl = NA_PTR_TYPE(rblapack_vl, doublecomplex*);
+  side = StringValueCStr(rblapack_side)[0];
+  if (!NA_IsNArray(rblapack_select))
+    rb_raise(rb_eArgError, "select (3th argument) must be NArray");
+  if (NA_RANK(rblapack_select) != 1)
+    rb_raise(rb_eArgError, "rank of select (3th argument) must be %d", 1);
+  n = NA_SHAPE0(rblapack_select);
+  if (NA_TYPE(rblapack_select) != NA_LINT)
+    rblapack_select = na_change_type(rblapack_select, NA_LINT);
+  select = NA_PTR_TYPE(rblapack_select, logical*);
   if (!NA_IsNArray(rblapack_p))
     rb_raise(rb_eArgError, "p (5th argument) must be NArray");
   if (NA_RANK(rblapack_p) != 2)
     rb_raise(rb_eArgError, "rank of p (5th argument) must be %d", 2);
   ldp = NA_SHAPE0(rblapack_p);
-  n = NA_SHAPE1(rblapack_p);
+  if (NA_SHAPE1(rblapack_p) != n)
+    rb_raise(rb_eRuntimeError, "shape 1 of p must be the same as shape 0 of select");
   if (NA_TYPE(rblapack_p) != NA_DCOMPLEX)
     rblapack_p = na_change_type(rblapack_p, NA_DCOMPLEX);
   p = NA_PTR_TYPE(rblapack_p, doublecomplex*);
+  if (!NA_IsNArray(rblapack_vr))
+    rb_raise(rb_eArgError, "vr (7th argument) must be NArray");
+  if (NA_RANK(rblapack_vr) != 2)
+    rb_raise(rb_eArgError, "rank of vr (7th argument) must be %d", 2);
+  ldvr = NA_SHAPE0(rblapack_vr);
+  mm = NA_SHAPE1(rblapack_vr);
+  if (NA_TYPE(rblapack_vr) != NA_DCOMPLEX)
+    rblapack_vr = na_change_type(rblapack_vr, NA_DCOMPLEX);
+  vr = NA_PTR_TYPE(rblapack_vr, doublecomplex*);
+  howmny = StringValueCStr(rblapack_howmny)[0];
+  if (!NA_IsNArray(rblapack_vl))
+    rb_raise(rb_eArgError, "vl (6th argument) must be NArray");
+  if (NA_RANK(rblapack_vl) != 2)
+    rb_raise(rb_eArgError, "rank of vl (6th argument) must be %d", 2);
+  ldvl = NA_SHAPE0(rblapack_vl);
+  if (NA_SHAPE1(rblapack_vl) != mm)
+    rb_raise(rb_eRuntimeError, "shape 1 of vl must be the same as shape 1 of vr");
+  if (NA_TYPE(rblapack_vl) != NA_DCOMPLEX)
+    rblapack_vl = na_change_type(rblapack_vl, NA_DCOMPLEX);
+  vl = NA_PTR_TYPE(rblapack_vl, doublecomplex*);
   if (!NA_IsNArray(rblapack_s))
     rb_raise(rb_eArgError, "s (4th argument) must be NArray");
   if (NA_RANK(rblapack_s) != 2)
     rb_raise(rb_eArgError, "rank of s (4th argument) must be %d", 2);
   lds = NA_SHAPE0(rblapack_s);
   if (NA_SHAPE1(rblapack_s) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of s must be the same as shape 1 of p");
+    rb_raise(rb_eRuntimeError, "shape 1 of s must be the same as shape 0 of select");
   if (NA_TYPE(rblapack_s) != NA_DCOMPLEX)
     rblapack_s = na_change_type(rblapack_s, NA_DCOMPLEX);
   s = NA_PTR_TYPE(rblapack_s, doublecomplex*);
-  howmny = StringValueCStr(rblapack_howmny)[0];
-  side = StringValueCStr(rblapack_side)[0];
-  if (!NA_IsNArray(rblapack_select))
-    rb_raise(rb_eArgError, "select (3th argument) must be NArray");
-  if (NA_RANK(rblapack_select) != 1)
-    rb_raise(rb_eArgError, "rank of select (3th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_select) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of select must be the same as shape 1 of p");
-  if (NA_TYPE(rblapack_select) != NA_LINT)
-    rblapack_select = na_change_type(rblapack_select, NA_LINT);
-  select = NA_PTR_TYPE(rblapack_select, logical*);
-  if (!NA_IsNArray(rblapack_vr))
-    rb_raise(rb_eArgError, "vr (7th argument) must be NArray");
-  if (NA_RANK(rblapack_vr) != 2)
-    rb_raise(rb_eArgError, "rank of vr (7th argument) must be %d", 2);
-  ldvr = NA_SHAPE0(rblapack_vr);
-  if (NA_SHAPE1(rblapack_vr) != mm)
-    rb_raise(rb_eRuntimeError, "shape 1 of vr must be the same as shape 1 of vl");
-  if (NA_TYPE(rblapack_vr) != NA_DCOMPLEX)
-    rblapack_vr = na_change_type(rblapack_vr, NA_DCOMPLEX);
-  vr = NA_PTR_TYPE(rblapack_vr, doublecomplex*);
   {
     int shape[2];
     shape[0] = ldvl;

data/ext/ztgex2.c

@@ -68,6 +68,7 @@ rblapack_ztgex2(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  wantq = (rblapack_wantq == Qtrue);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (3th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -77,11 +78,10 @@ rblapack_ztgex2(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*);
-  ldz = NUM2INT(rblapack_ldz);
   ldq = NUM2INT(rblapack_ldq);
-  j1 = NUM2INT(rblapack_j1);
+  ldz = NUM2INT(rblapack_ldz);
   wantz = (rblapack_wantz == Qtrue);
-  wantq = (rblapack_wantq == Qtrue);
+  j1 = NUM2INT(rblapack_j1);
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (4th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
@@ -92,17 +92,6 @@ rblapack_ztgex2(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_q))
-    rb_raise(rb_eArgError, "q (5th argument) must be NArray");
-  if (NA_RANK(rblapack_q) != 2)
-    rb_raise(rb_eArgError, "rank of q (5th argument) must be %d", 2);
-  if (NA_SHAPE0(rblapack_q) != (wantq ? ldq : 0))
-    rb_raise(rb_eRuntimeError, "shape 0 of q must be %d", wantq ? ldq : 0);
-  if (NA_SHAPE1(rblapack_q) != (wantq ? n : 0))
-    rb_raise(rb_eRuntimeError, "shape 1 of q must be %d", wantq ? n : 0);
-  if (NA_TYPE(rblapack_q) != NA_DCOMPLEX)
-    rblapack_q = na_change_type(rblapack_q, NA_DCOMPLEX);
-  q = NA_PTR_TYPE(rblapack_q, doublecomplex*);
   if (!NA_IsNArray(rblapack_z))
     rb_raise(rb_eArgError, "z (7th argument) must be NArray");
   if (NA_RANK(rblapack_z) != 2)
@@ -114,6 +103,17 @@ rblapack_ztgex2(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 (5th argument) must be NArray");
+  if (NA_RANK(rblapack_q) != 2)
+    rb_raise(rb_eArgError, "rank of q (5th argument) must be %d", 2);
+  if (NA_SHAPE0(rblapack_q) != (wantq ? ldq : 0))
+    rb_raise(rb_eRuntimeError, "shape 0 of q must be %d", wantq ? ldq : 0);
+  if (NA_SHAPE1(rblapack_q) != (wantq ? n : 0))
+    rb_raise(rb_eRuntimeError, "shape 1 of q must be %d", wantq ? n : 0);
+  if (NA_TYPE(rblapack_q) != NA_DCOMPLEX)
+    rblapack_q = na_change_type(rblapack_q, NA_DCOMPLEX);
+  q = NA_PTR_TYPE(rblapack_q, doublecomplex*);
   {
     int shape[2];
     shape[0] = lda;

data/ext/ztgexc.c

@@ -69,6 +69,7 @@ rblapack_ztgexc(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
+  wantq = (rblapack_wantq == Qtrue);
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (3th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
@@ -78,6 +79,30 @@ rblapack_ztgexc(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 (5th argument) must be NArray");
+  if (NA_RANK(rblapack_q) != 2)
+    rb_raise(rb_eArgError, "rank of q (5th argument) must be %d", 2);
+  ldz = 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*);
+  if (!NA_IsNArray(rblapack_z))
+    rb_raise(rb_eArgError, "z (7th argument) must be NArray");
+  if (NA_RANK(rblapack_z) != 2)
+    rb_raise(rb_eArgError, "rank of z (7th argument) must be %d", 2);
+  if (NA_SHAPE0(rblapack_z) != ldz)
+    rb_raise(rb_eRuntimeError, "shape 0 of z must be the same as shape 0 of q");
+  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*);
+  ilst = NUM2INT(rblapack_ilst);
+  wantz = (rblapack_wantz == Qtrue);
+  ldq = NUM2INT(rblapack_ldq);
   if (!NA_IsNArray(rblapack_b))
     rb_raise(rb_eArgError, "b (4th argument) must be NArray");
   if (NA_RANK(rblapack_b) != 2)
@@ -88,32 +113,7 @@ rblapack_ztgexc(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*);
-  wantq = (rblapack_wantq == Qtrue);
-  ilst = NUM2INT(rblapack_ilst);
   ifst = NUM2INT(rblapack_ifst);
-  wantz = (rblapack_wantz == Qtrue);
-  if (!NA_IsNArray(rblapack_z))
-    rb_raise(rb_eArgError, "z (7th argument) must be NArray");
-  if (NA_RANK(rblapack_z) != 2)
-    rb_raise(rb_eArgError, "rank of z (7th 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*);
-  ldq = NUM2INT(rblapack_ldq);
-  if (!NA_IsNArray(rblapack_q))
-    rb_raise(rb_eArgError, "q (5th argument) must be NArray");
-  if (NA_RANK(rblapack_q) != 2)
-    rb_raise(rb_eArgError, "rank of q (5th argument) must be %d", 2);
-  if (NA_SHAPE0(rblapack_q) != ldz)
-    rb_raise(rb_eRuntimeError, "shape 0 of q must be the same as shape 0 of z");
-  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*);
   {
     int shape[2];
     shape[0] = lda;

data/ext/ztgsen.c

@@ -95,65 +95,65 @@ rblapack_ztgsen(int argc, VALUE *argv, VALUE self){
 
   ijob = NUM2INT(rblapack_ijob);
   wantz = (rblapack_wantz == Qtrue);
-  wantq = (rblapack_wantq == Qtrue);
-  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);
-  n = NA_SHAPE1(rblapack_q);
-  if (NA_TYPE(rblapack_q) != NA_DCOMPLEX)
-    rblapack_q = na_change_type(rblapack_q, NA_DCOMPLEX);
-  q = NA_PTR_TYPE(rblapack_q, doublecomplex*);
   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);
-  if (NA_SHAPE1(rblapack_a) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of a must be the same as shape 1 of q");
+  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_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 q");
-  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_select))
-    rb_raise(rb_eArgError, "select (4th argument) must be NArray");
-  if (NA_RANK(rblapack_select) != 1)
-    rb_raise(rb_eArgError, "rank of select (4th argument) must be %d", 1);
-  if (NA_SHAPE0(rblapack_select) != n)
-    rb_raise(rb_eRuntimeError, "shape 0 of select must be the same as shape 1 of q");
-  if (NA_TYPE(rblapack_select) != NA_LINT)
-    rblapack_select = na_change_type(rblapack_select, NA_LINT);
-  select = NA_PTR_TYPE(rblapack_select, logical*);
+  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*);
+  wantq = (rblapack_wantq == Qtrue);
   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 q");
+    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*);
-  if (rblapack_lwork == Qnil)
-    lwork = (ijob==1||ijob==2||ijob==4) ? 2*m*(n-m) : (ijob==3||ijob==5) ? 4*m*(n-m) : 0;
-  else {
-    lwork = NUM2INT(rblapack_lwork);
-  }
+  if (!NA_IsNArray(rblapack_select))
+    rb_raise(rb_eArgError, "select (4th argument) must be NArray");
+  if (NA_RANK(rblapack_select) != 1)
+    rb_raise(rb_eArgError, "rank of select (4th argument) must be %d", 1);
+  if (NA_SHAPE0(rblapack_select) != n)
+    rb_raise(rb_eRuntimeError, "shape 0 of select must be the same as shape 1 of a");
+  if (NA_TYPE(rblapack_select) != NA_LINT)
+    rblapack_select = na_change_type(rblapack_select, NA_LINT);
+  select = NA_PTR_TYPE(rblapack_select, logical*);
+  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*);
   if (rblapack_liwork == Qnil)
     liwork = (ijob==1||ijob==2||ijob==4) ? n+2 : (ijob==3||ijob==5) ? 2*m*(n-m) : 0;
   else {
     liwork = NUM2INT(rblapack_liwork);
   }
+  if (rblapack_lwork == Qnil)
+    lwork = (ijob==1||ijob==2||ijob==4) ? 2*m*(n-m) : (ijob==3||ijob==5) ? 4*m*(n-m) : 0;
+  else {
+    lwork = NUM2INT(rblapack_lwork);
+  }
   {
     int shape[1];
     shape[0] = n;

data/ext/ztgsja.c

@@ -91,47 +91,36 @@ rblapack_ztgsja(int argc, VALUE *argv, VALUE self){
   } else {
   }
 
-  if (!NA_IsNArray(rblapack_v))
-    rb_raise(rb_eArgError, "v (11th argument) must be NArray");
-  if (NA_RANK(rblapack_v) != 2)
-    rb_raise(rb_eArgError, "rank of v (11th argument) must be %d", 2);
-  ldv = NA_SHAPE0(rblapack_v);
-  p = NA_SHAPE1(rblapack_v);
-  if (NA_TYPE(rblapack_v) != NA_DCOMPLEX)
-    rblapack_v = na_change_type(rblapack_v, NA_DCOMPLEX);
-  v = NA_PTR_TYPE(rblapack_v, doublecomplex*);
+  jobu = StringValueCStr(rblapack_jobu)[0];
   jobq = StringValueCStr(rblapack_jobq)[0];
   l = NUM2INT(rblapack_l);
-  jobu = StringValueCStr(rblapack_jobu)[0];
-  if (!NA_IsNArray(rblapack_q))
-    rb_raise(rb_eArgError, "q (12th argument) must be NArray");
-  if (NA_RANK(rblapack_q) != 2)
-    rb_raise(rb_eArgError, "rank of q (12th argument) must be %d", 2);
-  ldq = NA_SHAPE0(rblapack_q);
-  n = NA_SHAPE1(rblapack_q);
-  if (NA_TYPE(rblapack_q) != NA_DCOMPLEX)
-    rblapack_q = na_change_type(rblapack_q, NA_DCOMPLEX);
-  q = NA_PTR_TYPE(rblapack_q, doublecomplex*);
-  tolb = NUM2DBL(rblapack_tolb);
-  k = NUM2INT(rblapack_k);
   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);
-  if (NA_SHAPE1(rblapack_b) != n)
-    rb_raise(rb_eRuntimeError, "shape 1 of b must be the same as shape 1 of q");
+  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*);
-  tola = NUM2DBL(rblapack_tola);
+  tolb = NUM2DBL(rblapack_tolb);
+  if (!NA_IsNArray(rblapack_v))
+    rb_raise(rb_eArgError, "v (11th argument) must be NArray");
+  if (NA_RANK(rblapack_v) != 2)
+    rb_raise(rb_eArgError, "rank of v (11th argument) must be %d", 2);
+  ldv = NA_SHAPE0(rblapack_v);
+  p = NA_SHAPE1(rblapack_v);
+  if (NA_TYPE(rblapack_v) != NA_DCOMPLEX)
+    rblapack_v = na_change_type(rblapack_v, NA_DCOMPLEX);
+  v = NA_PTR_TYPE(rblapack_v, doublecomplex*);
+  jobv = StringValueCStr(rblapack_jobv)[0];
   if (!NA_IsNArray(rblapack_a))
     rb_raise(rb_eArgError, "a (6th argument) must be NArray");
   if (NA_RANK(rblapack_a) != 2)
     rb_raise(rb_eArgError, "rank of a (6th 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 q");
+    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*);
@@ -144,7 +133,18 @@ rblapack_ztgsja(int argc, VALUE *argv, VALUE self){
   if (NA_TYPE(rblapack_u) != NA_DCOMPLEX)
     rblapack_u = na_change_type(rblapack_u, NA_DCOMPLEX);
   u = NA_PTR_TYPE(rblapack_u, doublecomplex*);
-  jobv = StringValueCStr(rblapack_jobv)[0];
+  k = NUM2INT(rblapack_k);
+  if (!NA_IsNArray(rblapack_q))
+    rb_raise(rb_eArgError, "q (12th argument) must be NArray");
+  if (NA_RANK(rblapack_q) != 2)
+    rb_raise(rb_eArgError, "rank of q (12th 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 b");
+  if (NA_TYPE(rblapack_q) != NA_DCOMPLEX)
+    rblapack_q = na_change_type(rblapack_q, NA_DCOMPLEX);
+  q = NA_PTR_TYPE(rblapack_q, doublecomplex*);
+  tola = NUM2DBL(rblapack_tola);
   {
     int shape[1];
     shape[0] = n;